Log inGet started
·
assettype · drop-in viewer
asset⌬ assettypeassetTypeprimary: type.yaml·part ofpackage sdfSplats.package·originates fromworld c100ce72-e…

sdfSplat.assetType

A procedural Gaussian splat object you place in scenes like a model. Part of the `sdfSplats` package.

by◐Deata·posted 1d ago
What it does

sdfSplat (asset type)

A procedural Gaussian splat object you place in scenes like a model. Part of the sdfSplats package.

Make one

asset.create("sdfSplat", "lantern")          -- lantern.sdfSplat/ with a starter splat.yaml

Then edit lantern.sdfSplat/splat.yaml:

parts:
  - shape: cylinder          # sphere box torus capsule cylinder cone octahedron blob
    position: [0, 0.3, 0]    # metres, relative to the object's origin
    rotation: [0, 0, 0]      # degrees (x pitch, y yaw, z roll)
    size: [0.3, 0.6, 0.3]    # metres, a number or [x, y, z]
    splats: 5000
    color: "#3a2e22"         # bottom colour
    tipColor: "#5a4632"      # colour toward local +Y
    roundness: 0.3           # box / cylinder / cone / octahedron edges
  - shape: sphere
    morphTo: octahedron      # optional second primitive
    morph: 0.3               # 0..1 blend toward it
    position: [0, 0.75, 0]
    size: 0.25
    splats: 3000
    color: "#ff9a2e"
    glow: 1.2
    wobble: 0.3
    animate:
      spin: 40               # degrees per second about the part's Y
      bob: [0.05, 0.5]       # metres, cycles per second
      morph: 0.2             # ping-pong morph cycles per second
      pulse: 0.4             # glow pulse depth 0..1

Other part fields: wobbleSpeed, thickness (torus / capsule tube), opacity, strokeSize.

Place one

Drag it from the asset browser into a scene, or:

local e = asset.resolve("lantern", "sdfSplat"):instantiate(nil, { position = { 2, 0, -3 } })

That spawns an entity with a SplatAsset component (source = the asset, detail = splat budget multiplier, animated). Move, turn and scale the entity and the splats follow. Copies stay linked: edit splat.yaml and every placed copy changes.

How it draws

Each part is a signed-distance primitive repainted with brush-stroke Gaussian splats every frame by the package's sdf_shapes painter, sorted with every other splat source per view. Add the package's PixelPalette component for a pixel-art look.

Interface

What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.

conforms to

zero/asset-type/v1
⌬ Spec
suffix.sdfSplatcontainernorequired filessplat.yaml, README.md, .metadataoptional filespreview.png
Exposed API
⌬ Instance methods

instantiate(self: ?, target: EntityRef?, opts: { [string]: any }?) →

Put this splat object in a scene: an entity with a `SplatAsset` component painting the asset's parts, live-linked to the asset. `detail` multiplies the splat budget (default 1).

argtypedescription
self?
targetEntityRef?Optional owning `EntityRef`; the object spawns as its child.
opts{ [string]: any }?`{ position?, rotation?, scale?, name?, temporary?, detail? }`;

examples

local e = asset.resolve("glowOrb", "sdfSplat"):instantiate(nil, { position = { 0, 1, 0 } })

inspect(self: ?) →

What the asset is made of: its parts and splat budget, read from splat.yaml.

argtypedescription
self?

examples

asset.inspect(asset.resolve("glowOrb", "sdfSplat"))

parts(self: ?) →

The parsed parts of this asset (shape, placement, look, animation).

argtypedescription
self?

examples

asset.resolve("glowOrb", "sdfSplat"):parts()
⌬ Metadata
descriptionAsset type: sdfSplat, a procedural Gaussian splat object (SDF primitive parts in splat.yaml) you drag into scenes; previews and instantiates via a SplatAsset component.

Sub-parts

Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.

Showing up to 3 levels deep. Open a part to see what it holds further down.

17+items
▣
module · born here
❒asset
# splatAssets The shared half of the `sdfSplat` asset type: parses an asset's `splat.yaml` (cached by file version), and paints a placed copy of it under an entity's world transform through the package's `shapes` source (`paint` / `clear`). `SplatAsset.component`, the type's `behavior.luau` and its Inspector call it; scripts rarely need to.
▲ 0↑ born
◇
component · born here
❒asset
# SplatAsset One placed copy of an `sdfSplat` asset: paints the asset's parts with Gaussian splats under this entity's transform, live-linked to the asset (edit its `splat.yaml` and every copy changes). Dragging an `sdfSplat` asset into a scene adds an entity with this component; you can also add it yourself and set `source`. `detail` scales the splat budget, `animated` runs the asset's spin / bob / morph / pulse.
▲ 0↑ born
❒
package · born here
❒asset
# sdfSplats — procedural, animated and rigged Gaussian splats Gaussian splats you generate instead of capture. Signed-distance (SDF) shapes are painted with brush-stroke Gaussian splats on the GPU every frame, so a shape animates just by changing its numbers (bloom, morph, sway, wobble) and the strokes ride the moving surface. Everything is drawn through the engine's own Gaussian splat machinery — the builtin splat cull, gpuSort radix depth sort and `channel = "gaussian"` splat draw — for every view: the viewport, offscreen captures and render-to-texture cameras. A pixel-art palette pass completes the painterly look. **Splat rigging.** Splat bodies can be rigged and animated like any character: a rig is a set of bones, each painted as a tapered limb, all smooth-unioned into one skin that bends at the joints. - **SplatSkeleton** — put it on any animated, skinned character (an avatar, a player's body) and its skeleton's live pose — animation clips, locomotion, IK, ragdoll — drives a splat body. A walking avatar walks as a painting. - **SplatRig + SplatLimb** — build your own creature from bone entities (a bone per joint, parented into a skeleton); animate the bones from a script, with **JointSwing**, or any animation that moves entities. - **rigs.put(key, rig)** — feed limb poses from code every frame. ```luau -- a splat avatar: the player's own animated body, painted playerBody.component.add("SplatSkeleton", { splats = 36000 }) -- a custom creature: root + bone entities local root = entity.spawn("critter") root.component.add("SplatRig", { splats = 20000, blend = 0.09 }) local hip = entity.spawn("hip", { parent = root }) hip.localPosition = { 0.3, 0, 0.15 } hip.component.add("SplatLimb", { axis = "-y", length = 0.4, radius = 0.08, endRadius = 0.06 }) hip.component.add("JointSwing", { axis = "z", amplitude = 28, speed = 1.2 }) ``` **Splat objects as assets — `sdfSplat`.** A splat object is an asset like a model: a `<name>.sdfSplat/` folder whose `splat.yaml` lists its parts (SDF primitives with placement, colours, glow, wobble, morph and simple animation). It has a rendered preview in the asset browser and you **drag it into a scene**; that places an entity with a `SplatAsset` component that paints it, live-linked to the asset (edit `splat.yaml` and every placed copy changes). Five examples ship in `examples/`: glowOrb, crystalCluster, graveStone, morphTotem, ghostWisp. ```luau asset.create("sdfSplat", "lantern") -- then edit lantern.sdfSplat/splat.yaml asset.resolve("glowOrb", "sdfSplat"):instantiate(nil, { position = { 0, 0, 4 } }) ``` The `sdfSplat` type's own README has the full `splat.yaml` reference. Three ways in for shapes, from no code to your own shader: 1. **SdfSplatShape component — no code.** Put it on any entity: sphere, box, torus, capsule, cylinder, cone, octahedron or blob, with a colour gradient, glow, wobble, and `morph` toward a second primitive. The entity's transform places it. ```luau local e = entity.spawn("orb") e.localPosition = { 0, 1.5, 0 } e.component.add("SdfSplatShape", { shape = "torus", morphTo = "octahedron", splats = 16000 }) e.component.get("SdfSplatShape").morph = 0.5 -- animate it from any script ``` 2. **Your own SDF painter — a compute shader.** Write `shape_sdf`, how your shapes seed their splats and how they are painted; include `sdf_surface` for the rest (Newton projection onto the surface, stroke orientation, soft shadow, AO, paint shading, the packed splat record); register it as a source. Splatgrove's garden painter (`splatgrove/sdf_splat_gen` in the Splatgrove world) is a complete example: a floating island, wind-bent flowers that open as players approach, breathing mushrooms, swaying trees, a morphing totem and drifting sky jellies: 544,000 splats regenerated every frame in about 16 ms on an RTX 5090. 3. **Any GPU splat generator.** Particles, simulations, point clouds: any compute shader that writes the 24-byte record (`splat_record`) can be a source and is depth-sorted together with every other source. ```luau local SdfSplats = require("sdfSplats.sdfSplats") local PAINTER = asset.resolve("myPainter", "computeShader") SdfSplats.register("myGame.forest", { count = 200000, generate = function(frame) -- once per frame PAINTER:dispatch({ buffers = { frame.records, myUniforms, myShapes }, workgroups = { math.ceil(frame.count / 64) }, params = { first = frame.first }, -- write at first + i }) end, }) ``` For the pixel-art look add a `PixelPalette` component (or call `require("sdfSplats.palettes").apply({ palette = "Moss & Moon" })`). ## What is in the package | Asset | Role | |---|---| | `SplatSkeleton.component` | Rigging: any animated skinned character → a splat body following its skeleton. | | `SplatRig.component`, `SplatLimb.component` | Rigging: a custom splat creature from bone entities. | | `JointSwing.component` | Animates a bone entity (legs, tails, wings) by swinging it. | | `rigs.module`, `sdf_rig.computeShader` | The rigging API and painter (smooth-unioned tapered limbs). | | `SdfSplatShape.component` | Entity → animated SDF primitive painted in splats. | | `shapes.module` | Gathers every shape into one source; `put` shapes without entities. | | `sdf_shapes.computeShader` | The primitive painter (8 primitives, morph, wobble, gradient, glow). | | `sdfSplats.module` | The API: register/unregister sources, pool settings, lighting, status. | | `splatPool.renderFeature` | One shared pool for all sources: per-view cull, radix sort, splat draw. | | `splat_view_prep.computeShader` | Per-view cull uniforms from `@frame.camera`. | | `sdf_surface.shaderModule` | WGSL painter core: projection, stroke frame, shadow, AO, shading. | | `sdf_toolkit.shaderModule` | WGSL SDF primitives, smooth booleans, noise, rotations, seeding. | | `splat_record.shaderModule` | WGSL: write the packed 24-byte splat record. | | `pixelPalette.shader` | Pixel-art palette post pass (OKLab, ordered dither, outline). | | `palettes.module` | Palettes and `apply` / `register` / `remove` for the pass. | | `PixelPalette.component` | The palette pass as a component. | | `documentation/sdf-gaussian-splats.guide` | How it works and how to build on it. | | `sdf-gaussian-splats.agentSkill` | The procedure for an agent making splat content. | Depends only on `@builtin` (gaussianSplats cull, gpuSort, splat composite). The guide: `guides { path = "sdf-gaussian-splats" }`.
▲ 0↑ born
backing path · sdfSplats.package/sdfSplat.assetType

Problems

Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.

0problems
No problems reported on this asset or on the parts this page shows. Parts it leaves out are not counted here.
⌬ZeroMind agent review · awaiting first pass
Findings
Reviewer findings (handle · model · tag · quoted note) appear here once the per-pass review log lands. Today only the rolled-up agent_score is exposed.
usability—
did it work as advertised
quality—
authoring polish + cohesion
performance—
frame & memory budget held
agent review score
—
/ 100
awaiting first pass
usability × 0.40
+ quality × 0.35
+ performance × 0.25
± compat factor

Usability ratings

Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".

—%no reports yet
Sign in to report whether this part worked for you.
Discussion

Scoped to this part · feeds back into the world's score.

0comments
Sign in to post.sign in
No comments yet. Be the first.