SplatBridge — 3D Gaussian Splatting: Import, Stream & Play Real-World Scans
Stray Cats
$27.49
$54.99
50%OFF
(no ratings)
Jump AssetStore
Bring photoreal scans of real places into Unity. Import SOG, SPZ and 3DGS PLY Gaussian Splatting captures, stream city-scale scenes under a fixed GPU budget, add collision and VR. Built-in/URP/HDRP.SplatBridge brings photorealistic scans of real places into Unity — scenescaptured with 3D Gaussian Splatting, a technique that turns ordinary photosand drone footage into striking, explorable 3D. Drop a .sog, .spz or 3DGS .plyfile into your project and it renders in Built-in, URP or HDRP like any otherasset: walk through it, give it collision and gameplay, take it to VR. When acapture is too big for GPU memory, SplatBridge streams it under a fixed memorybudget you set once — city-scale scans included.📖 Full manual, troubleshooting table and tuning guide ship inside thepackage, in English and Japanese. 🎬 Demo video in the gallery above. All gallery images are unedited in-Unity captures.💬 Support: publisher contact on this page.## Import: one step, three formats**SOG** (PlayCanvas / SuperSplat), **SPZ** (Niantic, v3 gzip and v4 NGSP+zstd)and **3DGS PLY** (SH degree 0–3). Drop a bundled .sog, .spz or .ply into yourproject for a render-ready GaussianSplatAsset — no external converter, nocommand line. An unbundled SOG (meta.json plus its WebP files) imports throughan editor menu instead, in the same one step. superspl.at datasets import asthey are; to build a streamed SOG from your own .ply, use PlayCanvas's freesplat-transform CLI (one command, in the README), then bake it in the editor.## Rendering: every pipeline, correct compositing- **Every render pipeline.** Built-in, URP (Unity 6 Render Graph, with Compatibility Mode fallback) and HDRP (Custom Pass). Shaders ship inside the package and are included in player builds automatically — no "Always Included Shaders" setup.- **GPU depth sorting.** A radix sort in compute re-sorts the draw order as the camera moves, never on the main thread, with an automatic background CPU fallback where compute sorting is unavailable (specifics under Technical details).- **Render scale.** Draw splats into a downscaled offscreen target and composite: fill cost drops roughly with scale², UI and geometry stay full resolution. XR has a stereo-array version of the same lever.- **Correct compositing.** Splats depth-test against your scene, so scanned content sits behind walls and props instead of floating over them.## Streaming: city-scale under a fixed budgetLarge captures do not fit in GPU memory, so SplatBridge streams them under a**hard resident-splat budget** you set once.- **No per-dataset tuning.** Quality is judged in screen space, not by distance: the one quality knob, **Splat Quality Pixels (τ)**, means the same thing on a tabletop scan and on a city. It ships at a fixed **2 px on every platform**, so one scene ships to desktop, PCVR and Quest alike; an optional **Auto** preset resolves it per platform instead, letting mobile trade detail for fill automatically.- **Coarser, never holes.** The plan pays for every cell of the dataset before spending anything on detail, so an under-sized budget is absorbed by drawing the scene **coarser**, not by dropping parts of it.- **Know before you ship.** The bake log and the inspector report a **coverage gate** verdict up front: a budget too small even for the cheapest complete view is caught in the editor, not discovered on device. An optional debug log prints coverage, achieved quality, the error distribution and the frame-time knee, so tuning is measurement rather than guesswork.- **Fixed memory.** Max Resident Splats is a hard memory cap and the main performance lever — τ sets quality. The GPU buffer is allocated once at that size, with per-frame upload budgets, frustum culling and no-flash chunk swaps.- **Pre-baked, so the runtime never decodes.** A one-click bake (.splatbake) turns a streamed-SOG dataset into GPU-ready records, so a runtime chunk load is a seek and a read with no image decoding in the loop.- **Live in the editor.** The Scene view runs the real streaming loop before Play — same worker, same budget, same LOD cuts — and idles once converged; move the camera to resume.## Make it a gameA scan you can only look at is a screenshot. SplatBridge ships the parts thatturn one into a scene:- **Collision.** One context-menu entry builds a MeshCollider from the splats (opacity-weighted voxel occupancy with a weight threshold that filters out lone floater noise). Because it is ordinary static collision geometry, **CharacterController, Rigidbody, raycasts and NavMesh baking all just work** with stock Unity physics. Also available from code at runtime. Collision covers the whole dataset regardless of what is currently streamed in.- **Reveal / hide animation.** Five patterns (Scatter, FromPoint, Rain, Dissolve, Sweep) animate the **actual gaussians** in the vertex shader — no particle-to-splat handoff pop, and the fully revealed frame is exactly the normal render. It can wait for the streamer's first full coverage, so the scene converges at once instead of popping in.- **VFX Graph bridge.** Sample the live splat buffers from VFX Graph: particles that spawn on the scanned surface, inherit its color and sync to the reveal wave. Two ready-to-paste HLSL recipes are in the manual.- **Runtime loading.** SplatRuntimeLoader.LoadFromFile(path) loads .sog / .spz / .ply at runtime; errors surface as typed exceptions with the cause (unrecognized container, unsupported version, corrupt data …), not silent failure.- **Helpers.** A streaming/FPS debug HUD you can ship in builds, and a burned-in credit overlay for CC-BY scans.## VR — and experimental Meta Quest standalone**PC VR (URP) is a first-class target:** Single Pass Instanced and Multiviewstereo, verified on Quest 3 over Link (OpenXR). The sort follows the headpose, so depth ordering holds up as you look around.SplatBridge also runs on Quest 3 standalone (Android, OpenXR, Vulkan, Multiview) —the same importer, streamer, GPU depth sort and stereo path as on desktop,with one-time StreamingAssets extraction handled for you. It works on devicetoday.Standalone is labelled **experimental** on purpose. Performance on standalone hardwaredepends heavily on the size of your capture and on your settings, and tuningwork is ongoing. Treat it as something to prototype and measure with, not as aplatform where a given frame rate is guaranteed.Standalone rendering is **fill-rate bound** rather than CPU or sort bound, andthe package gives you the levers that move it. The streaming rules above stillhold: a lower budget renders coarser, and the coverage gate warns before youbuild.One more lever where fill binds: an experimental, opt-in **impostor** bakes thefar field into a billboard, so the live draw only pays for near splats. Theincluded Quest scene ships it on and tuned.A starting point on Quest 3 (then measure in your own scene):- Max Resident Splats: **1,000,000** — drop to 500,000 if your title's frame time is tight- Splat Quality Pixels (τ): **2 (the shipped default — leave it)**. In our Quest 3 testing the fixed 2 px held up; raise τ toward 8 (or select the Auto preset, which resolves to 8 px on Android/Quest) only if a heavy scene turns fill-bound- XR Splat Render Scale: **0.6**- Quad Extent Sigma: **1.4** (default 3) — much less fill; the size-aware sigma boost (on by default) keeps large on-screen splats round, not square-cropped- Sort Mode: **Auto** (GPU sort on Vulkan)None of that is per-dataset: τ is scale-free, so the same numbers carry over toyour next capture.The package README documents the Android build setup (IL2CPP / ARM64 /Vulkan, OpenXR with the Meta Quest feature group, Multiview, and URP rendererfeature setup), and the **tuning panel sample** below sweeps these knobsin-headset.## Included samples: 3 ready-made scenesPress Play once and everything runs.- **Demo scene.** An indoor classroom (1.9M splats, 86 MB) with a ready-to-play scene: streaming, a Sweep reveal, a camera dolly and physics balls rolling on a collider generated from the splats.- **Tuning panel.** An in-headset panel that shows the streaming and frame-time telemetry and lets you sweep the tuning knobs (budget, τ, render scale, quad extent) with the controller while wearing the device. Comes as a ready-made scene (XR rig, streamer and panel already wired): open it, build, and sweep.- **Quest scene.** A ready-made standalone-headset scene (XR rig, floor and streamer already wired) whose streamer carries the Quest configuration out of the box, so the first build you send to the device starts from settings that are known to run. Its README lists the Android/OpenXR project settings a scene cannot carry itself. Both XR scenes stream the classroom set.Every bundled dataset is our own content — nothing to credit.## Requirements- Unity 6000.x (tested on 6000.0–6000.5).- Built-in, URP 17.x or HDRP 17.x.- Windows / macOS desktop and Android (including experimental Meta Quest 3 standalone — see above). WebGL is not supported (streaming needs file IO and compute).- VR/XR is URP only (OpenXR). Built-in RP and HDRP XR are not supported.## Known limitations- Meta Quest 3 standalone support is **experimental** (see above): budget time to tune with the included panel, and treat it as experimental in your own planning.- Color uses the SH DC term only. SH bands 1–3 are imported and stored, but not yet used by the shader (view-dependent color is on the roadmap).- Streaming reads local files (no HTTP streaming yet) and requires the baked format; the importer produces it in one step.- Splat editing (delete / select / crop) is out of scope — use SuperSplat and re-export.## Roadmap (no dates promised, order may change)- Standalone Quest performance — continued optimization of the mobile GPU path, aiming to drop the experimental label- iOS (iPhone / iPad)- SH bands 1–3 in the shader- HTTP streaming of remote datasetsAll 1.x updates are free for purchasers.Supported formats- SOG (PlayCanvas / SuperSplat): bundled .sog and unbundled meta.json, format version 2. Streamed SOG (lod-meta.json) imports through the bake step.- SPZ (Niantic): v3 (gzip) and v4 (NGSP + zstd). v1/v2 are rejected with a clear error.- 3DGS PLY: SH degree 0–3, binary little-endian.- .splatbake: the package's own pre-baked streaming format (GPU-ready records + leaf table), produced in one step from the importer or an editor menu. It is a container of tagged sections, so later features can be added to the format without breaking bakes you have already made.Rendering- Unity 6000.x (tested on 6000.0–6000.5).- Built-in RP, URP 17.x (Unity 6 Render Graph, plus Compatibility Mode fallback), HDRP 17.x (Custom Pass). Shaders live inside the package and ship in player builds automatically.- Depth sorting: GPU radix sort on D3D12 / Vulkan / Metal; automatic threaded CPU counting-sort fallback elsewhere. Sorting never blocks the main thread. The camera pose is checked every frame; a re-sort triggers past a small position/rotation threshold.- Splat render scale (offscreen + composite) for desktop and a separate stereo-array version for XR, with opt-in occlusion by opaque scene depth.VR / XR- URP + OpenXR only (Built-in RP and HDRP XR are not supported).- Single Pass Instanced and Multiview stereo. PC VR verified on Quest 3 over Link (D3D12) and desktop OpenXR runtimes. Use an XR Origin rig and the OpenXR plugin.- Meta Quest 3 standalone: experimental. IL2CPP / ARM64 / Vulkan / Multiview; StreamingAssets sources are extracted to device storage automatically on first run. An in-headset tuning panel sample is included.- Optional far-field impostor (experimental, off by default): the resident far leaves are baked into a view-facing billboard array every few frames and composited, so the live draw covers only the near region. The near/far radius is derived from a screen-space parallax error budget β (in pixels), the focal length and a head-movement budget — there is no distance threshold to set. Per-eye stereo bake by default; an optional mono bake writes one view plus a per-pixel depth channel and reprojects each eye through it, at half the bake cost. Requires the GPU sort path.Streaming- Hard resident-splat budget (single pre-allocated GPU buffer); screen-space quality metric (τ, scale-invariant) with coverage-first level selection — under-budget renders coarser rather than dropping cells.- A coverage gate evaluates, at bake time and in the inspector, whether the budget can pay for the dataset's cheapest complete view. Verdicts: Ok, RefinementMarginUnsatisfied (full coverage, little room left to refine) and CoverageInfeasible (the budget cannot cover the dataset — raise it or re-bake).- Per-frame upload budgets, frustum culling with hysteresis, no-flash chunk swaps, GC-friendly steady state.- Local file IO only (StreamingAssets / absolute paths); no HTTP streaming yet.- Building a streamed-SOG source from a plain .ply uses the free PlayCanvas splat-transform CLI (one command, documented in the README); superspl.at downloads and existing lod-meta.json sets import directly.- Editor Preview (Inspector toggle on GaussianSplatStreamer, Basic section, default ON): drives the same streaming worker, Max Resident Splats budget and LOD cuts from the Scene view camera outside Play mode. Pumps until converged, then idles (no player-loop pumping or repaints), and resumes on camera or object movement. Does not mark the scene dirty. Also visible in the Game view while editing, using the Scene view camera pose as an approximation for LOD/sort. The far-field impostor stays disabled during editor preview (Play mode or device only). If editing feels heavy with a large dataset, turn the toggle off — the streamer is then inert outside Play mode.Gameplay integration- MeshCollider generation from splats (editor context menu or runtime API): standard static collision, works with CharacterController, Rigidbody, raycasts and NavMesh baking.- Reveal/hide animation (5 patterns) running on the actual gaussians in the vertex shader; VFX Graph bridge sampling the live splat buffers; runtime loading API with typed exceptions.Dependencies and code- Pure C# decoders (including the WebP VP8L decoder) — no native plugins, no P/Invoke; the only bundled managed DLLs are ZstdSharp and System.Runtime.CompilerServices.Unsafe. Third-party notices included (MIT).- Source code included — everything installs into a single folder, Assets/SplatBridge. Assembly definitions keep Runtime and Editor separated; compiles warning-free on import.- All bundled demo data is original content created by the publisher: one synthetic scene (rendered from the CC0 "Classroom" Blender demo file — public domain, no attribution required — and reconstructed with our own Gaussian Splatting pipeline) and one photographic capture made by us. Nothing in the package carries an attribution requirement. An attribution overlay helper component is included and prewired in the demo scene, for your own captures that do need a credit line.Not supported- WebGL (streaming needs file IO and compute shaders).- Splat editing (delete / select / crop) — edit in SuperSplat and re-export.- SH bands 1–3 are imported and stored but not yet used by the shader.Documentation: full manual, troubleshooting table and tuning guide in thepackage (English and Japanese).AI coding assistants (Anthropic Claude) were used throughout development as apair-programming tool, always under human direction and review: generating andrefactoring C# source code, writing automated tests, and draftingdocumentation (English and Japanese).All AI-assisted code was developed test-first and is verified by an extensiveautomated test suite (a pure-C# decoder test suite plus Unity PlayModerendering tests with pixel-level verification on Built-in RP, URP and HDRP),and additionally verified by a human on real hardware (Windows, macOS, PC VRand Meta Quest 3).No generative AI was used to create any bundled content. Both includeddatasets are our own: one is a photographic 3D Gaussian Splatting capture weshot ourselves; the other was produced by rendering views of the CC0"Classroom" Blender demo file (public domain, no attribution required) with aconventional renderer and reconstructing them with our own Gaussian Splattingpipeline — a photogrammetric reconstruction, not a generative model. Store andmarketing images are composited from actual in-engine renders of those scenes.The package contains no AI-generated textures, models, audio, or other mediaassets, and no content requiring third-party attribution.
