AssetStore Price down information

beta

Bring photoreal scans of real places into Unity. Import SSOG, SPZ and 3DGS PLY Gaussian Splatting captures, stream city-scale scenes under a fixed GPU budget, add collision and VR. Built-in/URP/HDRP.Bring real places into Unity with 3D Gaussian Splatting: explorable scansreconstructed from photos. Drop in a .sog, .spz or 3DGS .ply, add collisionand gameplay, or take it to VR. Built-in, URP and HDRP are supported. Largecaptures stream under a fixed GPU budget — 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.- **View-dependent color.** The capture's SH bands 1–3 are evaluated per  view, so gloss, glass and wet surfaces shift with the camera as recorded;  switchable per object. In 1.0.4, Training color mode is the default for  Linear projects; Legacy mode preserves the previous rendering. Far-field  billboard baking now retains SH color and refreshes when SH settings change.## 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. If all finest full slices fit afterpage rounding and transition reserve, full detail stays resident automatically.Otherwise screen-space LOD adapts within the same cap.- **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.## Edit scans in UnitySelect regions in Scene View, preview the result, then split, delete or extract.Box, sphere, cylinder, cone and polygon prism selections work with both SplatObjectsand baked Streamers. Mirror Copy creates reflected parts; separated parts are ordinaryGameObjects for Unity animation. Clone Repair and runtime clipping are Experimental.- **Realtime shadows (URP/HDRP).** Cast onto Unity Lit meshes and receive their  shadows, with independent Cast Shadows / Receive Shadows switches, both off by  default. This adds shadows; it does not remove lighting captured in the scan.## Make it a game- **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). It is ordinary static collision geometry, so  **CharacterController, Rigidbody, raycasts and NavMesh baking all just work**.  Also available from code at runtime, and it 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.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.Use the included tuning panel and the manual's Quest setup guide to adjustbudget, render scale and splat size on your device. Standalone performanceremains scene-dependent and experimental.## Included samples: 3 ready-made scenesThe smaller demo download includes source SOG. First open ClassroomDemo inthe Editor and wait for streaming data to be generated; later openings reusethe verified cache. Then press Play.- **Demo scene.** An indoor classroom (1.0M splats, 175 MB), ready to play:  streaming, view-dependent color, a Sweep  reveal, a camera dolly and physics balls on a splat-generated collider.- **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: 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 your first device build starts from settings 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 plan around that.- Streaming reads local files (no HTTP streaming yet) and requires the baked  format; the importer produces it in one step.- Editing preserves existing LODs; it does not regenerate them or merge scans.- Clone Repair and runtime clip editing are experimental.  Runtime clipping changes drawing, not collision geometry.- New shadow paths are validated on desktop Metal; XR and other graphics APIs  still need validation. Built-in shadow integration is not supported.## Roadmap (no dates promised, order may change)- We are considering further enhancements to the editing tools.- Standalone Quest performance — continued optimization of the mobile GPU  path, aiming to drop the experimental label- iOS (iPhone / iPad)- 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.- Axis conventions: a Source Convention setting (Standard 3DGS — the PLY / SOG /  SPZ default — plus Y-up right-handed, Z-up right-handed and Unity Native)  brings files written in other frames in the right way up; collision meshes  follow it.Rendering- SH bands 1–3 for imported assets and baked streams. In 1.0.4, Training  color mode is the project-wide default: use Linear color space for  training-space compositing and corrected splat projection. Legacy is  available for the previous rendering. Linear is the validated configuration  for this update.- Far-field billboard baking preserves SH color and invalidates cached views  when SH data, bands or color mode change. HDRP retains its live far-field path.- 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- Automatically selects all finest full slices when their page-rounded cost  fits the effective budget after transition reserve. Otherwise adaptive  screen-space LOD applies; the memory cap is unchanged.- 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.Editor editing and shadows (1.1.0)- Shared Scene View editing for GaussianSplatRenderer (SplatObject) and baked  GaussianSplatStreamer: five region shapes, three-state selection preview,  split/delete/extract and multi-axis Mirror Copy. Separated parts remain  ordinary Unity GameObjects. Renderer outputs use .asset; Streamers use .splatbake.- Clone Repair (donor picker and planar clone brush) and runtime clipping are  Experimental. Runtime clipping supports up to eight volumes, OR/AND, and optional  pixel clipping. It does not rebuild colliders. Offline edits select Gaussian  centers and preserve existing LOD records; no LOD regeneration or scan merging.- URP/HDRP realtime shadows: independent Cast Shadows / Receive Shadows, default  off. Directional/Point/Spot; HDRP also Rectangle. Casting uses resident splats;  receiving defaults to Shared Surface with an automatically generated mesh,  with Direct also available. Shared surfaces approximate the geometry. Receiving  bypasses the far-field color cache. Cost depends on scene and shadow settings. No baked GI/Shadowmask, ray-traced shadows or Built-in  shadow integration. Captured illumination remains. Desktop Metal validated;  Shared Surface targets desktop mono. Shadow paths are not yet validated on  XR or other graphics APIs.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.- 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).- General selection brushes/lasso, scan merging and LOD regeneration.- View-dependent color (SH bands 1–3) costs 18 / 48 / 90 bytes per resident  splat (fp16) in a separate buffer; it is per-object switchable and the Quest  sample ships it off. SH Bands 0 disables view dependence; select 1–3 to  enable it. Band changes apply on reload. Disabling before loading avoids  the SH GPU buffer; toggling off after loading retains that buffer.  Live streamed SOG sources stream the base color only.Demo distribution: source SOG is included under Editor. First scene openingconverts it to a validated StreamingAssets bake, reused on later openings.Existing mismatched files are not overwritten. Only the bake is used in Players.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.