| Plume Triangle | Minimal: load shader, create colored triangle mesh, draw |
| Mesh Lines | Line list, line strip, and line loop draw modes |
| Mesh Points | Point mesh with animated colors |
| Mesh Indexed | Indexed cube (8 vertices, vertex map for 12 triangles) |
| Mesh Draw Range | Animate draw range to reveal a grid of triangles over time |
| Mesh Dynamic | Animated trianglestrip (circle with wave + color animation), setVertexAttribute + flush |
| Mesh Attributes | Animate per-vertex position and color via setVertexAttribute; GUI and terminal commands |
| Mesh Primitives | The MeshGen procedural factories (Block SPL): one of each primitive (box, cylinder, cone, plane, grid) in a row plus a sine-wave heightmap terrain, each returning a standard Mesh drawn with a lit N·L shader so the generated normals read correctly |
| Instanced Mesh GPU | GPU-instanced rendering (SSBO): 1,000 animated cubes in a single draw call |
| Grass Field | Enhanced instancing (SSBO): 4,096 grass blades in one draw, each with its own colour + height + wind-phase (addInstanceColored/setInstanceParams), plus per-instance frustum culling (setCullingEnabled, visibleCount) |
| Material Textures | Full PBR material map set (base/metallic/roughness/normal/AO/emissive) assigned to a script mesh from Wren; derivative-TBN normal mapping |
| Custom Material Pack | A pack shader binds its own textures + params at set 5 (mesh.setCustomTexture/setCustomColor/setCustomParamFloat), read via #include "plume3d.slang" — no engine change |
| Wind Sway | The global frame-uniform block (set 0 binding 4): Graphics.setWind + the host frame clock drive a shader that sways and colour-pulses with plume3d_time() |
| Refraction | Opaque colour capture (set 0 binding 6): Graphics.opaqueCaptureEnabled lets a transparent quad sample the captured opaque scene via plume3d_opaqueColor at a wobbled screen UV — colour bands bend through it |
| Sky Demo | Atmosphere (A#6): a procedural gradient then an environment-cubemap sky (Graphics.setSky + Texture.loadCubemap/setEnvironmentMap), an ambient fill (setAmbient) and atmospheric distance fog (setFog) that dissolves a receding row of cubes |
| RTT Monitor | Script render-to-texture (A#7): a picture-in-picture “monitor” panel shows the scene from a second camera, rendered into a persistent capture texture with Graphics.submitCapture and sampled through the set-5 material path (mesh.setCustomTexture) — a capture is just a Texture |
| Planar Reflection | Planar reflection (A#4): a transparent water plane reflects a row of cubes floating above it — Graphics.setPlanarReflection(true, planeY) renders the scene mirrored across the plane into a half-res target (set 0 binding 7) that the water shader samples screen-space via plume3d_reflection |
| Scene Depth | Scene depth in the mesh ABI (PLM-263): a transparent quad reads the OPAQUE scene depth behind it at set 0 binding 5 — #include "plume3d.slang" → plume3d_sceneDepthLoad(int2(SV_Position.xy)) under the Graphics.opaqueCaptureEnabled(true) gate — and paints a shoreline that tracks four bands at four different depths (foam where geometry is close behind, blue where deep); the shoreline / foam / depth-tint primitive the Water pack is built on |
| Water Mask Demo | Water masking (PLM-273): a transparent water plane discards fragments inside a boat’s world-XZ footprint so an open-hull boat sits dry (interior shows the seabed) instead of flooded — the footprint is a game-driven set-5 custom-param mask (setCustomColor at byte offsets 0/16), and arbitrary shapes drive the same discard from a mask texture. Plus a depth-based shoreline foam via the PLM-263 scene depth (binding 5). Zero engine change — composed from already-shipped surface |
| Spline | The Spline curve primitive (Block SPL): a 5-point Catmull-Rom curve drawn as a line strip at constant arc-length spacing (positionAtDistance), with sampleFrames(16) rotation-minimizing orientation frames drawn as gizmos (tangent red / normal green / binormal blue) — the 13-number frames a mesh extruder consumes |
| Spline Mesh Demo | Spline mesh extrusion (Block SPL): a river MeshGen.ribbon swept along a spline and conformed onto a heightfield (each station snapped to the ground so the water hugs the hills) plus an arching MeshGen.tube, terrain built as one MeshGen.heightmap visual + a matching Jolt heightfield collider |
| Scatter Demo | Scatter / placement (Block SPL): ~10,600 foliage instances placed into one InstancedMesh two ways — Scatter.onSurface projects 8,000 blades onto a heightfield, Scatter.alongSpline lines 2,600 along a terrain-following path — one GPU-instanced draw with per-instance culling + wind sway |
| Scatter Multi | Two GPU-instanced meshes in one frame (PLM-257): green blades left, blue right — the per-draw instance-SSBO sub-allocation so multiple InstancedMeshes render independently (the prerequisite for multi-prototype scatter) |
| Toon Pack Demo | The Toon / Stylized-Shading content pack (PLM-261): a cel/toon surface shader (N·L quantized into hard bands + a Fresnel rim, tuned via set-5 params) plus a depth-edge ink outline post effect — a whole stylized look built with zero engine change, on only the mesh ABI, the post ABI, and Graphics.addPostEffect |
| Sky / Weather Demo | The Sky / Weather content pack (PLM-262): a pure-Wren TimeOfDay driver paints a full day/night cycle — sky, sun, ambient, fog — over the engine’s neutral A#6 atmosphere knobs (setSky / setAmbient / setFog + a directional sun Light) via apply(t), t in [0,1); the policy half of the engine-vs-pack boundary, with zero engine change. Steps sunrise → noon → sunset → night |
| Weather Demo | The Weather content pack (PLM-265): rain, snow, thunder, wind, dynamic clouds, height fog and rain-splash ripples, driven by a pure-Wren Weather state machine (clear/rain/snow/storm) over the engine’s neutral knobs, with zero engine change. Instanced rain/snow (GPU-animated fall via precip.slang, one draw each), a cloud sky shader on setSky (clouds.slang), a rain-ripple ground shader (wet_ground.slang) swapped in while raining, plus setAmbient/setFog/setFogHeight/setWind policy and a storm lightning flash. Combines the Toon pack’s shader half with the Sky pack’s policy half. Cycles clear → rain → snow → storm |
| Foliage Pack Demo | The Grass / Foliage / Trees content pack (PLM-266): instanced grass, foliage and trees with wind sway + back-light translucency (leaves glow when the sun is behind them), built with zero engine change — one foliage.slang on the enhanced-instancing path. A grass field + procedural trees (lit trunk + a canopy of instanced leaf cards), all foliage in one instanced draw. The demo proves the shader; the production path is Blender-authored — author → Bake Scatter (PLM-250) → Scene.loadBlendScene/instantiateScatter (Block BLD) → render with foliage.slang active. Authored-object colliders (PLM-267) and spawn masking (PLM-268 — a geometry-nodes density mask or the Bake-Scatter grayscale mask image) now ship; multi-part tree prototypes and LOD/billboards remain roadmap |
| Water Demo | The stylized Water content pack (PLM-273): stylized water in two variants side by side sharing one core — PBR (realistic) left, Toon (anime) right, over the same waves — built with zero engine change. The shared water_common.slangh (mesh ABI) does Gerstner waves + analytic/ripple normals, PLM-263 scene-depth colour + Beer–Lambert absorption, A#3 refraction (halo-guarded) and A#4 planar reflection + Schlick fresnel, and an infini-water horizon fade; each variant supplies only the style remap (PBR soft foam/spec vs Toon quantized bands + hard foam line + stepped glint + contact rim). Pure content on the set-5 custom params under the opaqueCaptureEnabled gate. Now also dips the camera below the surface for an underwater post (tint → deep, fog, wobble, caustic, vignette). The surface half; rivers and buoyancy have since shipped, while rain bloops, a masked buoyant hull, custom textures and per-bend flow remain follow-ups |
| River Demo | A spline water mesh (PLM-273): a Catmull-Rom Spline swept into a MeshGen.ribbon with the shared stylized Toon water flowing downstream — the ripples and foam scroll along the global Graphics.setWind vector. Rocks in the channel make foam; the green banks give the PLM-263 depth-based shoreline. Zero engine change — the Block SPL spline/ribbon + the water pack. Per-bend flow is a follow-up |
| Water Playground | The interactive water capstone (Block WTR2 — Water Fidelity, ADR 0094): free-fly and dive below the surface, toggle the Realistic ↔ Toon variant and the weather at runtime, and spawn buoyant crates/barrels that ride the same waves the surface renders. Composes the whole water program — the two surface variants, the new Graphics.setWaterPlane / Graphics.cameraWaterState camera-submersion API, an underwater post cross-faded on the submersion amount, a camera-facing waterline meniscus, and Water + Physics.applyBuoyancy buoyancy |
| Buoyancy Demo | Jolt buoyancy on the stylized water (PLM-270 / PLM-271, ADR 0091): the new Water class is the CPU mirror of the water shader’s Gerstner waves — one Water drives both the rendered surface (applyToMesh → set-5 p3) and the height query (heightAt), so floats bob on the waves you see. Physics.applyBuoyancy samples multiple probe points per body: rafts sampling their four corners visibly rock/tilt, while cubes at density 0.35 / 0.7 / 1.25 float at different heights (low = floats high + snappy, high = sits low + sluggish) |
| Water Raymarch | A self-contained ray-marched stylized water scene — seabed, sky, foamy wave crests and turquoise caustic shallows — rendered entirely in one full-screen post shader with no scene geometry; the owner’s Slang-Playground shader (a gameidea.org stylized-water adaptation) ported to the Plume3D post ABI (#include "plume3d_post.slang", plume3d_time(), mouse via post param p0.xy, a can_draw trigger quad). Drag the mouse to orbit. A demo of the existing full-screen post path + Input, not a new engine feature |
| Toon Water | The owner’s ray-marched TOON water ported onto a real mesh (water_toon.slang) — a banded depth palette, crisp cel foam at shorelines/crests, INK graphic marks, banded sun light and a toonSky rim reflection — over the same Alekseev octave waves as Water Raymarch’s seascape look, so buoyant floaters ride the visible swell. Sees the real scene (seabed + floaters) via the grab-pass + scene depth. Press 1 to compare the realistic Seascape look. A demo of the set-5 custom material + grab-pass + scene depth, not a new engine feature |
| Sprite Demo | Billboarded sprites: one texture, four tinted camera-facing quads, depth-sorted by the engine |
| SDF Text Demo | SDF text: world-space and screen-space labels, outline, wrapping, rich-text markup |
| UI Demo | Retained-mode UI: a .ui card (title, subtitle, interactive button) loaded and rendered full-window |
| UI Widgets | Retained-UI interactive widgets: a toggle and a slider whose state the game polls to recolour a swatch |
| UI Canvas | Retained-UI custom drawing: a game draws node boxes, bezier wires, and labels into a type="canvas" element |
| UI 9-Slice Demo | Retained-UI textured 9-slice: two different-sized frames share one image-by-path PNG + a .ui.component sidecar, corners unstretched |
| UI Input Demo | Retained-UI editable text input: a Name field (initial text) and a City field (placeholder), focus by click, read via elem.text |