Skip to content

About

SteamVR mod for Split/Second

Resources

Stars

5 stars

Watchers

0 watching

Forks

Repository files navigation

SplitSecondVR 1.2

Seated VR for Split/Second (SteamVR / OpenVR, or OpenXR).

Play Split/Second in a headset, seated, in true stereo 3D: the menus and the races. Built and tested with a Valve Index (90 Hz) and an RTX 3060.

Note

Unofficial fan mod; not affiliated with the game's publisher or developer. Built for the Steam release (build 385319); the retail release's code is the same.

Download the latest release

Contents: What it does · Requirements · Install · Resolution · Performance · Keys · Settings · Upscaling · OpenXR · How it works · Known limitations · Troubleshooting · What is new · License

What it does

  • Menus and races in true stereo 3D, seated: the game's picture is rendered side by side, each eye with its own matrices (geometry, deferred lights, particles, floor reflections, vignette, lens flare and motion blur are all done per eye).
    • Menus: head rotation moves the view; the viewer is pulled back from the stage so the cards are not in your face.
    • Races: your head turns and leans the in-game camera. The track, the cars and the world behind you are drawn wherever you look (the game's culling follows your head).
  • Intro movies and loading screens appear on a virtual screen in front of you.
  • The game's 2D layer (menu text, "press Enter", the race HUD) is a sharp panel of its own instead of being drawn across both eyes.
  • Cinematic bars and fades (race intro, pause menu, tutorials) are bars and dimming locked to your head.
  • 60 fps: the game runs at 60 fps instead of its own 30, with the engine still doing its original 60 simulation steps a second, so physics, timers and scripted events behave as at 30 fps. The VR runtime reprojects that to the headset's rate.
  • The window on the desktop is a small "Playing in VR" window by default (so the game does not draw a second picture for the monitor), or, if you prefer, one eye or both eyes in a borderless window over the monitor: DesktopView. See Settings.
  • Upscaling (optional): the headset can get a larger, sharpened picture than the game renders, made on the graphics card (AMD FidelityFX Super Resolution 1.0). See Upscaling.
  • Game controls are unchanged; the game controller keeps working while you are in the headset and the desktop window is not the one in front.

Requirements

  • Windows
  • SteamVR (or, instead, an OpenXR runtime that has a 32-bit build: see OpenXR)
  • Split/Second (32-bit, build 385319, the Steam release or the retail release; on another build the 60 fps patch checks the game's bytes first and does nothing)
  • A graphics card that runs Direct3D 11. An RTX 3060 runs 3840x2160 at High quality; see Performance

Install

  1. Download the zip of the latest version from the releases page and unzip it so that the SplitSecondVR folder sits inside your Split Second folder (next to SplitSecond.exe), e.g. ...\steamapps\common\SplitSecond\SplitSecondVR\
  2. Run SplitSecondVR\install.bat (copies d3d9.dll next to SplitSecond.exe). uninstall.bat removes it again.
  3. Start SteamVR with the headset on, then launch Split Second from Steam. SteamVR is also started for you; the mod keeps trying for 10 minutes. If the headset is not connected when the game starts, the game runs flat and VR starts by itself once the runtime sees the headset. (To use OpenXR instead of SteamVR's OpenVR, see OpenXR.)
  4. In Options > Graphics pick the extra resolution entry, or write Resolution=3840x2160 (any size) under [Render] in the ini (see Resolution), and keep Quality on Low, Medium or High (Very High renders at 2x2 supersampling: about 2.5x the GPU work of High, see Performance).
  5. Intro movies, loading screens and anything else that is not a 3D scene appear on the virtual screen in front of you. F9 recentres and puts the screen in front of you again.
  6. The game runs in a window on the desktop (it no longer takes the whole screen exclusively): by default a small window that says "Playing in VR". The game controller works whatever window is in front; for the keyboard, click that window once so that it has the focus. See DesktopView under Settings.

To go back to the plain game at any time: run SplitSecondVR\uninstall.bat.

What you see

Where What happens
Title, main menu, season / free race screens Stereo 3D scene. Head rotation moves the view (rotation only: it stays where the game's camera is). The viewer is moved back by MenuPullBack (3 m) and up by MenuLift (0.4 m).
Races Stereo 3D scene. You also lean. RacePullBack (0 m) moves the viewer back.
Menu text, "press Enter", race HUD A panel in front of you (HudWidth / HudDistance / HudHeight / HudCurve, metres). Num+ / Num- make it 5 % bigger / smaller while playing and the log tells the HudWidth to keep; HudOverlay=0 draws it into the picture instead.
Cinematic bars, fades, pause menu Bars and dimming locked to your head, sliding in and out as the game's do; the HUD panel follows your head while they are up.
Intro movies, loading screens The virtual screen (ScreenWidth / ScreenDistance / ScreenHeight).

Menus and races are told apart automatically; SceneKind=1 or 2 forces menu or race.

Resolution

The back buffer is split in two (1920x1080 = 960x1080 per eye), which is soft in an Index. With Stereo on, [Render] Resolution defaults to 2880x1620 (1440x1620 per eye, about the Index panel) and adds one more entry to Options > Graphics > Resolution: pick it there once, the game remembers it. Or write Resolution=3840x2160 (any size) under [Render] in the ini: the game then starts with that size every time.

Size Per eye Notes
1920x1080 960x1080 the game's own entry; light, soft
2304x1296 1152x1296 Resolution=2304x1296; for when "free VA" gets low
2880x1620 1440x1620 the extra entry the mod adds (about the Index panel)
3840x2160 1920x2160 a built-in entry; with Quality High a good setting for an RTX 3060

Going higher costs address space (the game is 32-bit): with Log=1 the "free VA" figure in the once-a-second stats: lines of the log shows how much is left in a race. Keep it above ~300 MB.

Performance

Measured on an RTX 3060 with a Valve Index (Num7 timing probe, race start, 3840x2160 back buffer = 1920x2160 per eye):

Quality GPU work per frame Result
High about 10 ms (geometry 2.4, lights 1.5, main passes 3.4 including per-eye motion blur 1.5, shadows / cube maps 1.3, the mod's own Present work 0.8) A race runs at 47-52 fps: the rest of the 20 ms frame is the game's own CPU work (simulation, draw submission, frame limiter), not the GPU, which is about half idle.
Very High about 22-30 ms (2x2 supersampling, 7680x4320; motion blur alone 5.8 ms) 29 fps in the same race and SteamVR reprojecting. Free address space was still ~600 MB, so it runs, but it did not look any better in the headset than High.

Stereo itself is cheap: the proxy takes under 1 ms of CPU a frame, the second eye costs the extra geometry and lights above. Faster cards can use Very High, higher resolutions or the per-eye motion blur at full size; slower ones should lower the resolution before the quality. Details: source\NOTES.md, sections 7t and 7w.

Keys

Key What it does
F9 Recentre (sit comfortably, look straight ahead, press F9) and put the virtual screen in front of you. With Api=openvr this is SteamVR's own seated zero pose; with Api=openxr it is the mod's own (see OpenXR).
F8 FPS gauge on / off (same as FpsCounter in the ini; see Settings)
Num+ / Num- HUD panel 5 % bigger / smaller
Num0 Wider culling off / on (needs CullWiden), to compare
Num5 Save the picture given to the headset as SplitSecondVR_frame_NN.bmp (+ SplitSecondVR_hud_NN.bmp)
Num6 Save the G-buffer / HDR / floor-reflection targets (for bug reports)
Num7 Timing probe (needs Log=1): once a second in a race the log gets the GPU time per rendering phase and per shader, and the CPU time of the proxy and of the real draw calls; Num7 again switches it off
Num8 / Num9 Probe captures (pass list and draw commands of two frames; shader summary)

The keys are virtual-key codes in the ini (RecenterKey, CullToggleKey, DumpKey).

Settings

SplitSecondVR.ini (in the SplitSecondVR folder, read at start-up; edit with the game closed) holds only the options most people need. Every option is listed below; add a line under its [section] to use it (keys left out use the default shown). Delete the ini to go back to all defaults.

The mod has three states:

Enabled Stereo State
0 any Off. The proxy does nothing: no VR, no stereo, no 60 fps patch, no hooks. The game runs as it is (one small workaround keeps its level loading as fast as without the DLL, see source\NOTES.md 7s). The DLL stays loaded, so uninstall.bat is still the way to get the game exactly as it was.
1 1 VR.
1 0 Flat. No VR session, no stereo, no wider culling; only Use60Fps still does something.

The ini that ships has six settings:

Setting Default What it does
[General] Enabled 1 0 = the proxy does nothing at all
[VR] Stereo 1 The VR mod: stereo scenes, the VR session, the wider culling. 0 = the plain game, no VR
[VR] MotionBlur 1 The game's camera motion blur (only drawn at High quality and up): 1 = drawn per eye with head turns left out (costs 2-3 ms a frame), 0 = off. The built-in default is 1 (on); the shipped ini shows 0 so the option is visible - edit the value or delete the line to turn the blur on
[VR] Api openvr How the headset is reached: openvr = SteamVR's OpenVR, openxr = the system's active OpenXR runtime (see OpenXR: it needs a runtime with a 32-bit build). If OpenXR cannot start, the game stays flat and the log says why
[VR] DesktopView off What the window on the desktop shows while the headset runs: off = a small window saying "Playing in VR", left / right / both = that eye / both eyes in a borderless window over the monitor (see below)
[Render] Use60Fps 1 The game runs at 60 fps instead of its own 30 (done while the game runs: no file is changed); 0 = the game's own 30 fps. The engine keeps its original 60 simulation steps a second (one step per frame at the original step length), so physics, timers, animations and scripted events behave as at 30 fps (the community 60 fps patch runs 120 steps a second, which made step-counted things like gates run twice as fast). Needs GPU headroom: lower the in-game quality if it stays under 60. It checks the game's bytes first and does nothing on another build

[General]

Key Default What it does
Enabled 1 Master switch (see above)
Log 0 1 = write SplitSecondVR.log (start-up facts, one stats line a second, VR / stereo events, WATCHDOG: lines if the game freezes)

[VR] (ignored when Stereo=0)

Key Default What it does
Stereo 1 See above
Api openvr openvr = SteamVR's OpenVR, openxr = the system's active OpenXR runtime; anything else is read as openvr
OpenXRRuntime (empty) Only with Api=openxr: the full path of the .json of the OpenXR runtime to use instead of the system's active one (empty = the system's). Used for this game only
DesktopView off What the window on the desktop shows while the headset runs. off = a normal small window with the game's icon and "Playing in VR" (the game's picture is not drawn there at all, which saves GPU time; click the window to give the game the keyboard; the game controller works without that). left, right, both = the window is made borderless and covers the whole monitor and shows the left eye's view, the right eye's view, or both side by side (menus and loading screens, which the headset shows on its virtual screen, are shown whole). The game is always run in a window (never exclusive full screen) so that this works, and a flat game without a headset yet is a borderless window over the monitor too. Clicking another window does not minimise the game, and the game cannot move the mouse pointer while the headset runs. The HUD panel is not part of this picture, as it is not part of the picture handed to the headset
ScreenWidth, ScreenDistance, ScreenHeight 3.6, 3.0, 0.0 The virtual screen for flat pictures (metres: width, distance, height relative to the eyes)
HudOverlay 1 The game's 2D layer is a panel of its own; 0 = drawn into the picture
HudWidth, HudDistance, HudHeight 8.64, 6.0, 0.0 The HUD panel (metres)
HudCurve 0 Curvature 0..1. Only works with Api=openvr
HudLock 2 2 = the HUD panel follows your head while the game's bars are up (cinematics, pause menu, tutorials) or the race camera follows your head, 1 = always, 0 = never
MenuPullBack, MenuLift 3, 0.4 How far the viewer is moved back / up in menus (metres)
RacePullBack 0 How far the viewer is moved back in races (metres)
SceneKind 0 0 = menus and races are told apart automatically, 1 = always a menu, 2 = always a race
EyeLights, EyeRays 1, 1 Deferred lights and screen-space passes are rebuilt per eye (1 = on)
EyeCameraPos 3 Each eye's own camera position for specular and the floor reflection (keep at 3)
Vignette, LensFlare 1, 1 1 = per eye; 0 turns one off; Vignette=2 / LensFlare=0 give the game's mono version
MotionBlur 1 The game's camera motion blur (drawn at High quality and up): 1 = per eye with MotionBlurStrength, head turns excluded (costs 2-3 ms a frame); 0 = replaced by a plain copy. With Stereo=0 the game draws its own blur
MotionBlurStrength 0.5 Scale of the per-eye blur (1 = the game's)
Upscale 0 1 = the stereo scene is upscaled on the graphics card before the headset runtime gets it: the game renders at its usual resolution and the headset gets a picture UpscaleFactor times as wide and high (an edge-adaptive upscale, the algorithm of AMD FidelityFX Super Resolution 1.0, and a sharpening). The virtual screen and the HUD panel are untouched. Off by default; see Upscaling
UpscaleFactor 1.5 How many times as wide and high the headset picture is, 1 to 4 (3840x2160 at 1.5 gives 5760x3240)
UpscaleSharpness 0.75 The sharpening after the upscale: 0 = none, 1 = the strongest
FpsCounter 0 1 = a small gauge in the headset shows how many frames a second the game presents (in menus and races, not on the virtual screen), with a graph of the last 18 seconds under it. It stays in front of your face, a little to the lower left, and is green at the rate the game aims for (60, or 30 without Use60Fps), yellow below it and red far below. The line of the graph has the same colours and is scaled from the lowest to the highest rate of those seconds. F8 switches it in game
RecenterKey, CullToggleKey, DumpKey, FpsKey 0x78, 0x60, 0x65, 0x77 Virtual-key codes (hex): F9, Num0, Num5, F8
Headless 0 1 = test mode without a headset (shared texture and frame dump only; used by the test scripts); Ipd (0.064) is then the eye separation; FakeHeadYaw / FakeHeadPitch / FakeHeadSweep turn a fake head by degrees / degrees per second

Culling

Key Default What it does
CullWiden 2 In races the game's culling frustum is widened to where your headset looks, so turning your head does not show missing objects. 2 = races only, 1 = everywhere (shows more of the menu stage and its debris), 0 = off. Forced off when Stereo=0
CullTurn 1 In races the game's own camera state is turned to where your head looks, as if you had moved it with the right stick, so the track, cars and the world behind you are drawn
CullTurnNode 2 2 turns the state the game's systems read, 1 turns the camera object made from it
CullTurnExtra 1 Fallback for the first frame: also turns the copies the draws read (found by a short scan, a hitch at the start; skipped when CullTurnNode works)
CullWidenExtra 1 The widening also reaches the camera objects the draws use
CullPredict 1.0 The camera turn looks this many frames ahead along your head's last turn
CullHeadAware, CullMarginDeg, CullMargin 1, 12, 0.3 With CullTurn=0: the widened frustum follows your head; degrees added on every side; the older margin as a tangent

[Render]

Key Default What it does
Use60Fps 1 See above
Resolution 2880x1620 with Stereo on The size of the extra entry in Options > Graphics, written as 3840x2160. When the line is in the ini (not left out or commented), that size is also the resolution the game starts with: it is put into the game's settings file (Documents\Disney Interactive Studios\Split Second\config_ss.cfg, a copy of it is kept once as config_ss.cfg.splitsecondvr.bak) before the game reads it, so the ini wins over what was picked in the options at every start. Leave the line out to use the game's own choice
ForceNoVSync on with Stereo Present without V-Sync (the game's own frame limiter and the compositor pace the frames)
StartAtSavedSize, StartWidth, StartHeight, FitDesktopWindow 0 Window size handling

Upscaling

With Upscale=1 under [VR] (off by default) the game still renders at its usual resolution and the headset gets a picture UpscaleFactor times as wide and high, made on the graphics card after the frame is drawn: an edge-adaptive upscale (the algorithm of AMD FidelityFX Super Resolution 1.0, EASU) followed by a sharpening (RCAS) whose strength is UpscaleSharpness. Each eye is done on its own, so nothing is taken across the seam. It applies to the stereo scene (races and menus drawn in 3D); the virtual screen and the HUD panel are untouched. It works with both Api values.

  • Set UpscaleFactor yourself (1 to 4, default 1.5): there is no automatic size. UpscaleSharpness is 0 to 1 (default 0.75).
  • The upscaled picture is kept in two textures of its size (about 75 MB each at 5760x3240) next to the game's own, in a 32-bit program: if the game runs out of memory late in a race (watch free VA in the log's stats: lines), lower UpscaleFactor or set Upscale=0.
  • The headset panel has fewer pixels per eye than the game's 3840x2160 picture, so at that resolution the gain is small; the upscale pays off when you lower the game's resolution (for example the 2880x1620 entry) and let the graphics card make up the size.

OpenXR (optional)

Since 1.2. SplitSecondVR reaches the headset through SteamVR's OpenVR by default. Set Api=openxr under [VR] in SplitSecondVR.ini (the shipped ini already has the line, set to openvr) to use OpenXR instead: the game then runs on the system's active OpenXR runtime (SteamVR's or another one). Without the line, or with Api=openvr, nothing changes.

[VR]
Api=openxr
  • The runtime needs a 32-bit build. Split/Second is a 32-bit program and sees only the OpenXR runtime that is registered for 32-bit programs: the ActiveRuntime value in HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Khronos\OpenXR\1 has to point to a runtime .json whose library is a 32-bit DLL (SteamVR: ...\SteamVR\steamxr_win32.json). SteamVR registers one from version 2.17. Whether another runtime has a 32-bit build is for its maker to say.

  • OpenXRRuntime (under [VR], empty by default) is the full path of the .json of the OpenXR runtime to use instead of the system's active one, for this game only: for a runtime that is not the active one, or whose 32-bit build is registered somewhere the loader does not look. A relative name is looked for in the SplitSecondVR folder. Only read with Api=openxr.

    OpenXRRuntime=C:\Program Files (x86)\Steam\steamapps\common\SteamVR\steamxr_win32.json
  • If OpenXR cannot start (no 32-bit runtime, no headset, a failed session) the game stays on the monitor and SplitSecondVR.log (with Log=1) says why, in lines that start with OpenXR:. The mod does not switch to OpenVR by itself; set Api=openvr for that. While the runtime reports no headset the mod tries again every 5 s for 10 minutes, like with OpenVR.

  • What is the same: stereo scenes, the HUD panel, the virtual screen, the 60 fps option, the culling, and all other settings and keys.

  • What differs:

    • Recentring: OpenXR has no way to ask the runtime to recentre, so F9 sets the mod's own seated zero pose (your head's position and heading at that moment). A recentre done in the runtime itself is followed too.
    • Panels: the virtual screen and the HUD panel are OpenXR quad layers instead of SteamVR overlays. HudCurve (a curved panel) has no effect, and SteamVR's overlay settings do not apply to them.
  • Pictures reach the runtime as images copied on the GPU into OpenXR swapchains, and only when the game has drawn a new one, so the cost is about the same as with OpenVR.

  • openxr_loader.dll in the SplitSecondVR folder is the 32-bit OpenXR loader of the Khronos Group (see LICENSE_openxr.txt). It is only loaded with Api=openxr; copy it too if you update by replacing single files.

  • OpenXR is new in 1.2. It has been run in a Valve Index through SteamVR's OpenXR runtime, where a race ran at the same frame rate as with OpenVR (the GPU, not the API, was the limit at Very High). Other runtimes are untested: please send SplitSecondVR.log with any problem.

How it works

Split/Second is 32-bit Direct3D 9 with a SecuROM + Steam stub, so SplitSecondVR is a d3d9.dll proxy that patches the game at runtime (Direct3D vtable hooks; the executable's own imports are left alone, because SecuROM crashes the game if CreateFile is patched in SplitSecond.exe).

  • The game's vertex shaders get the per-object TransViewProj matrix. The proxy remaps it per eye (the headset's per-eye projection, your head pose and a per-eye offset) and draws every object twice in the main 3D pass, into the left / right half of the render target. Deferred light volumes, particles, the floor reflection, vignette, lens flare and motion blur are re-expressed in each eye's own camera.
  • The game's UI pass is redirected to a transparent texture and shown as a panel of its own; the cinematic bars and fades are taken out of it and drawn per eye as head-locked bars.
  • The game gets a Direct3D 9Ex device, so the finished picture is handed to the VR runtime as a shared texture (a ring of three), without going through the CPU. A compositor thread owns the OpenVR or OpenXR session and resubmits the latest picture with the head pose it was rendered for, so the runtime reprojects the game's 60 fps to the headset's rate.
  • In races the game's own camera state is turned to where your head looks, and the culling frustum is widened, so what the game decides to draw covers what the headset sees.
  • 60 fps is done at runtime: one simulation step per frame at the original step length.

Source code: github.com/TwoAyEm/SplitSecondVR. Start with source/NOTES.md (design notes and findings); build with source\build.bat deploy (needs Python 3; installs the Zig compiler with pip the first time; close the game first), or source\build.bat nodeploy to only build. GitHub Actions (.github\workflows\build.yml) builds the same d3d9.dll and the release zip on Windows; a pushed tag v<version> publishes the zip.

Known limitations

  • The vignette and lens flare are drawn per eye; light shafts are untouched; the race's cascaded shadows and reflections are mono; cascaded shadows and objects far outside the view still follow the game's own camera.
  • Rolled cinematic cameras can be uncomfortable.
  • The eye views of DesktopView=left / right / both do not show the HUD panel (it is a separate texture, as in the headset's picture) and show the game's cinematic bars; the keyboard needs the game's window to have the focus.
  • With Api=openxr, HudCurve has no effect (see OpenXR).
  • Very High quality renders at 2x2 supersampling and is about 2.5x the GPU work of High (see Performance).

Troubleshooting

  • Nothing happens / the game is flat: start SteamVR first; run uninstall.bat to go back to the plain game. With Api=openxr start the OpenXR runtime instead and read the OpenXR: lines in SplitSecondVR.log (set Log=1): they say whether a 32-bit runtime was found, whether it sees a headset and how far the start got (see OpenXR).
  • The game freezes or crashes: set Log=1 under [General], play again and send SplitSecondVR.log (look for WATCHDOG: lines). If the game does not start at all, set Enabled=0 (or run uninstall.bat). SecuROM crashes the game if CreateFile is patched in SplitSecond.exe itself; the proxy leaves the executable's imports alone.
  • Something looks wrong in the headset: press Num5 while it is on screen. The mod saves SplitSecondVR_frame_NN.bmp (the picture given to the headset) and SplitSecondVR_hud_NN.bmp in the SplitSecondVR folder: attach them to the report. Num6 saves the G-buffer / HDR / floor-reflection targets.
  • Slow (under 60 fps): lower the in-game Quality first (Very High renders at 2x2 supersampling), then the resolution. Num7 (with Log=1) writes timing lines to the log.
  • The game runs out of memory late in a race: the game is 32-bit. With Log=1 read the "free VA" figure in the stats: lines; keep it above ~300 MB by using 2880x1620 or 2304x1296.
  • The keyboard does nothing: the game only reads the keyboard while its window has the focus. Click the "Playing in VR" window once (the game controller does not need that).
  • The window on the desktop is in the way: set DesktopView=off (a small window; move or minimise it as you like).
  • To run the game flat, set Stereo=0 (no VR; Use60Fps still works), or Enabled=0 (the mod does nothing), or run uninstall.bat.
  • Bug reports should include SplitSecondVR.log: set Log=1 under [General], reproduce the problem, close the game, and send SplitSecondVR\SplitSecondVR.log.

What is new

Version 1.2

OpenXR as an alternative to SteamVR's OpenVR

  • [VR] Api=openxr runs the mod on the system's active OpenXR runtime instead of SteamVR's OpenVR. Api=openvr, the default, is unchanged. [VR] OpenXRRuntime picks another runtime's .json. See OpenXR. Run in a Valve Index through SteamVR's OpenXR runtime; a race ran at the same frame rate as with OpenVR.
  • New files next to openvr_api.dll: openxr_loader.dll (the 32-bit OpenXR loader of the Khronos Group) and LICENSE_openxr.txt. The loader is only used with Api=openxr. install.bat says that an OpenXR runtime can be started instead of SteamVR.

The window on the desktop

  • New: [VR] DesktopView (off by default, ported from BlurVR). off: a small window with the game's icon and "Playing in VR"; the game does not draw a picture for the monitor, which saves GPU time. left, right, both: a borderless window over the monitor with that eye's view, or both eyes side by side. See Settings.
  • The game now always runs in a window (it used to be exclusive full screen at the video mode's size), which is what makes the modes above possible.
  • Input while you are in the headset: the game controller is read in the background, so it keeps working when another window has the focus; the game no longer minimises itself when you click another window; and it can no longer pin the mouse pointer to a corner of the screen. The keyboard still needs the game's window to have the focus (click it).

Resolution

  • New: [Render] Resolution=3840x2160 replaces CustomWidth / CustomHeight (which are no longer read). It is still the extra entry in the game's resolution list; when the line is written in the ini it is also the resolution the game starts with, every time (the size is put into the game's settings file, a copy of which is kept once as config_ss.cfg.splitsecondvr.bak). Leave it out to use the size picked in the game's options.

Upscaling and gauge (both off by default)

  • New: an upscaler ([VR] Upscale=1, with UpscaleFactor and UpscaleSharpness): the game renders at its usual resolution and the headset gets a larger picture, made on the graphics card with AMD FidelityFX Super Resolution 1.0 (an edge-adaptive upscale and a sharpening), ported from BlurVR. New file LICENSE_fsr.txt. See Upscaling.
  • New: an FPS gauge in the headset ([VR] FpsCounter=1, or F8 in game), ported from BlurVR: the frame rate the game presents, with a graph of the last 18 seconds, coloured against the rate the game aims for.

For developers

  • The OpenXR headers are in source\third_party\openxr; the code is in source\src\openxr_runtime.cpp, upscale_d3d11.cpp, desktop_view.cpp and desktop_message.cpp (source\NOTES.md, sections 7y to 7aa). build.bat now also links gdi32.
  • New host checks in source\tools: openxr_check.py (the loader and the runtime without the game; with --system it starts the runtime and runs test frames), upscale_check.py and desktop_message_check.py.
  • The README is now README.md; CLAUDE.md describes the code for AI assistants.

Version 1.1

  • The cinematic bars are recognised by their instructions, not by the whole shader. The retail release carries the same code as the Steam build, but its bar vertex shader differs in comment bytes only, so the bars at the race start were missing there.
Version 1.0

The first release: a d3d9.dll proxy that renders the game's menus and races in true stereo for a Valve Index.

  • Per-eye matrices for the geometry, deferred lights, particles, floor reflections, vignette, lens flare and motion blur.
  • Head-aware culling and a head-following camera in races.
  • The game's 2D layer as a sharp HUD panel; movies and loading screens on a virtual screen; cinematic bars and fades locked to your head.
  • A 60 fps mode that keeps the engine's simulation step.
  • Source, build script, release tools, GitHub Actions build and design notes (source/NOTES.md) included.

License

SplitSecondVR is released under the BSD 3-Clause License. openvr_api.dll is Valve's and comes with its own license (LICENSE_openvr.txt). openxr_loader.dll is the Khronos Group's OpenXR loader (Apache-2.0 or MIT, LICENSE_openxr.txt). The upscaling follows AMD's FidelityFX Super Resolution 1.0 algorithm (MIT, LICENSE_fsr.txt).

About

SteamVR mod for Split/Second

Resources

Stars

5 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages