raea/3d

raea/3d holds what a scene uses beyond Bevy's own components: glTF models (<Model>, <Part>), physics and soft bodies (<Physics>, <Body>, <Goo>), Gaussian splats (<Splat>), matchmoves, instancing and scattering, grass, fire, decals, 3D text, and custom shader passes (<FramePass>, <MeshPass>, <Compute>). It also re-exports the primitives and effects most scenes need, so a quick scene can import from one path. Bevy's camera, lights, materials and meshes are under raea/camera, raea/light, raea/pbr and raea/mesh, named as Bevy names them.

import { AbsoluteFill, staticFile } from "raea";
import { Model, Physics } from "raea/3d";
import { Camera3d } from "raea/camera";
import { DirectionalLight } from "raea/light";
import { Transform } from "raea/transform";

function Scene() {
  return (
    <AbsoluteFill style={{ background: "#14161c" }}>
      <Camera3d transform={Transform.fromXyz(0, 1.6, 5).lookingAt([0, 0.5, 0])} />
      <DirectionalLight transform={Transform.fromXyz(3, 5, 4).lookingAt([0, 0, 0])} illuminance={11200} shadow_maps_enabled />
      <Model src={staticFile("media/chair.glb")} />
    </AbsoluteFill>
  );
}

See 3D for building, lighting and checking a scene.

import { about, AmbientOcclusion, AntiAliasing, Atmosphere } from "raea/3d"

raea/3d exports 70 components, 4 hooks, 26 functions, 3 classes, 12 values, 126 types. Source: sdk/raea/src/3d.tsx.

#Components

#AmbientOcclusion

Screen-space ambient occlusion: creases, corners and the ground under things darken where the sky's and the room's light can't reach. It darkens ambient and environment light (an , an ), not the direct light of a sun or a lamp. Turns multisampling off, so the edges are smoothed by SMAA instead (see ). Put it inside the Canvas3D, once; the first frame's holds for the piece.

Bevy: bevy_pbr::ssao::ScreenSpaceAmbientOcclusion.

Takes AmbientOcclusionProps's props.

#AntiAliasing

How the 3D's edges are smoothed. Put it inside the Canvas3D, once; the first frame's holds for the piece.

Bevy: bevy_anti_alias::smaa::Smaa, bevy_anti_alias::fxaa::Fxaa.

Takes AntiAliasingProps's props.

#Atmosphere

A procedural sky: Bevy's physically based atmosphere (Earth's air), drawn behind everything and lit by the DirectionalLights, so a sun low on the horizon makes a sunset. Inside the Canvas3D, once.

Bevy: bevy_light::Atmosphere.

Takes AtmosphereProps's props.

#BevyComponent

A Bevy component on the part it's inside (a Mesh, a Model, an ImagePlane, a light or the camera), applied through the TypeRegistry: how a compiled-in Bevy plugin is driven (sdk/raea/docs/bevy-plugins.md), and how any of Bevy's own reflected components reaches a part in every build. Agents use the generated, typed wrappers (one per component), not this directly.

Used in: ui/widgets/viewport_node, 3d/3d_shapes, 3d/3d_scene, shader/automatic_instancing, shader/storage_buffer, shader/shader_prepass, shader/array_texture, shader/gpu_component_array_buffer, and 6 more.

#BevyResource

A Bevy resource (a plugin's settings: gravity), applied through the TypeRegistry. Inside the Canvas3D.

Used in: shader_advanced/deferred_raymarch.

#Bloom

Glow around bright parts (emissive materials, strong highlights). Put it inside the Canvas3D.

Bevy: bevy_post_process::bloom::settings::Bloom.

Takes BloomProps's props.

Used in: 3d/bloom_3d, 3d/mesh_ray_cast.

#Body

A rigid body inside : drawn where the simulation has it this frame.

#BufferMesh

A mesh from its own vertex buffers, as the geometry of a (Bevy's Mesh built from attributes): a terrain from a height field, a procedural shape, a ribbon, an imported point list. Drawn as flat triangles, or with indices and normals as Bevy's indexed Mesh.

Bevy: bevy_mesh::mesh::Mesh.

Takes BufferMeshProps's props.

Used in: shader_advanced/specialized_mesh_pipeline.

#Canvas3D

Only for layered: the 3D is drawn in the page's order, at the box of the nearest positioned element around it (the whole frame when there's none; B3 H7), at that box's size and aspect:

Takes Canvas3DProps's props.

Used in: ui/images/image_node, ui/images/ui_texture_slice_flip_and_tile, ui/images/image_node_resizing, ui/images/ui_texture_atlas_slice, ui/images/ui_texture_slice, ui/images/ui_texture_atlas, ui/layout/grid, ui/layout/ghost_nodes, and 94 more.

#Capsule

A capsule (Bevy's Capsule3d, three.js's CapsuleGeometry): [radius, length of the straight part], standing up (along y); its whole height is length + 2 x radius. A character's stand-in, a pill, a collider's look.

Also takes the props of CapsuleProps (args).

#Capsule3d

From Bevy's bevy_shape::Capsule3d: A 3D capsule primitive centered on the origin A three-dimensional capsule is defined as a surface at a distance (radius) from a line

Also takes the props of Capsule3dProps (radius, half_length, args).

#Compute

A compute over the frame, in the 3D beside the camera; several run in the order written, before the cameras draw.

Rust: raea_sys_compute::Computes.

Takes ComputeProps's props.

Used in: shader/compute_shader_game_of_life, shader_advanced/compute_mesh.

#Cone

A cone: [radius, height], its point up (along y).

Bevy: bevy_shape::Cone.

Also takes the props of ConeProps (args, radius, height).

#Cuboid

Bevy's Cuboid: <Cuboid half_size={[1, 0.5, 1]} /> is a Box of args [2, 1, 2].

Also takes the props of CuboidProps (half_size); BoxProps (args).

#Cylinder

[radiusTop, radiusBottom, height], standing up (along y) as three.js has it.

Bevy: bevy_shape::Cylinder.

Also takes the props of CylinderProps (args, radius, half_height).

#Decal

A picture pressed onto whatever surface it lies across: a label on a jar, a stain on a counter, tiles on a wall, a sticker on a laptop (Bevy's forward decal; the camera gets a depth prepass for it). Placed and keyed like any part, so it moves and fades with a render's clock and a game's play alike.

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<bevy_pbr::extended_material::ExtendedMaterial<bevy_pbr::pbr_material::StandardMaterial, bevy_pbr::decal::forward::ForwardDecalMaterialExt>>.

Takes DecalProps's props.

#DepthCopy

Inside a Camera3d: its depth buffer copied each frame, after its prepass and before its main pass, into a depth image a Material samples (Bevy's shader_advanced/render_depth_to_texture, whose depth-only camera has Bevy's DepthPrepass, RenderTarget::None and Msaa off).

Rust: raea_sys_phase::DepthCopy.

Used in: shader_advanced/render_depth_to_texture.

#DepthOfField

A lens's depth of field: what's nearer or farther than the camera's focus blurs. Put it inside the Canvas3D; pull focus by animating the camera's focus. Inside a Camera3d it is Bevy's component on the camera, its focal_distance the camera's focus.

Bevy: bevy_post_process::dof::DepthOfField.

Takes DepthOfFieldProps's props.

#Echoes

Copies of a part trailing it: count echoes at offsets step apart (metres; or a function of the echo's number), in a flat glowing material, so a fork "duplicates" along a line.

Also takes the props of PartProps.

#Entities

A world's entities drawn by the engine (no React element per entity): every entity with a Mesh component ({shape: a Manifold expression or a Solid's expr, color, roughness, metalness}) and a Transform ({x, y, z, rx, ry, rz in radians, scale}) is a mesh, placed in world space (a child's Transform is in its parent's). Give it the world at the frame: <Entities world={game.at(useCurrentFrame())} />. Needs the engine's tables.

#Entity

A bare Bevy entity: a Transform where it's placed (static) and Visibility, and nothing else until its children add Bevy's own components through the TypeRegistry. A Handle field takes an asset path ("ball.glb#Mesh0/Primitive0", "wood.png"), an inline asset (a StandardMaterial's fields as an object) or, for a Mesh, a Manifold shape ("shape:box(1, 1, 1)"); an Entity field takes another part's name or row id, or entity bits. So Mesh3d, MeshMaterial3d, Sprite, ChildOf and the rest of Bevy's components are reachable without a hand-written element.

Used in: ui/widgets/viewport_node, 3d/3d_shapes, 3d/atmospheric_fog, 3d/3d_scene, 3d/parenting, stress_tests/many_foxes, camera/projection_zoom, animation/animated_transform, and 4 more.

#Environment

Light from all around, out of a panorama: soft light from the sky and reflections of it in every glossy or metal surface (image-based lighting), and with background the panorama as the sky. Put it inside the Canvas3D, once a frame; its src, intensity, rotation and background may change from frame to frame (a cut from a hall to a street). Bevy's EnvironmentMapLight with maps already filtered is . Its panorama is filtered by Bevy's generator and, with background, drawn as the sky (engine/render environment.rs):

Bevy: bevy_light::probe::GeneratedEnvironmentMapLight. Bevy's Skybox from its own cubemap is <Skybox>..

Takes EnvironmentProps's props.

#EnvironmentMapLight

Bevy's EnvironmentMapLight with its own prefiltered maps, as Bevy's examples put one on the camera: light from all around and its reflections, from cubemaps already filtered (an filters a panorama itself). Put it inside the Canvas3D, once; the first frame's holds.

Bevy: bevy_light::probe::EnvironmentMapLight.

Takes EnvironmentMapLightProps's props.

#Fire

A fire: a flame drawn as a volume, its tongues rising, curling and tearing off as it burns, with a flickering light on its surroundings. Every pixel of it is a function of the frame (rising 3D noise in a tapering envelope), so a render of any frame equals its play. Stand it on its fuel (a pyre, a brazier); put embers and smoke round it yourself.

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<raea_render::engine::fire::FireMaterial>.

Takes FireProps's props.

#Fisheye

A fisheye lens on the camera: a pass over the 3D after tone mapping (the page over it stays straight). Every value animates per frame; a lens's vignette and colour fringes are 's. Put it inside the Canvas3D.

Takes FisheyeProps's props.

#Fog

Distance fog: far things fade into color. Inside the it is Bevy's DistanceFog on that camera, with all of Bevy's fields (an atmospheric falloff, the sun's colour); inside the Canvas3D it fogs the scene's camera by near, far or density.

Bevy: bevy_pbr::fog::DistanceFog.

Takes FogProps's props.

Used in: 3d/fog, 3d/atmospheric_fog.

#FogVolume

A box of air that light shows in: dust in a sunbeam, smoke, a haze of blood. Needs a in the Canvas3D; lights marked volumetric throw shafts through it, and every light's glow fills it softly. A part, so it keeps its name across frames: animate its density, colour and placement.

Bevy: bevy_light::volumetric::FogVolume.

Takes FogVolumeProps's props.

#FramePass

A full-screen pass over the scene camera's frame, beside the camera; several run in the order written. With a frame they run on its cells, before the look's composite.

Rust: raea_sys_framepass::FramePasses.

Takes FramePassProps's props.

Used in: shader_advanced/custom_post_processing, shader_advanced/fullscreen_material.

#GBufferPass

Inside a Camera3d with Bevy's DepthPrepass and DeferredPrepass: your shader over the whole view, written into the deferred G-buffer after the deferred prepass (depth compared GreaterEqual), so Bevy's deferred lighting lights it as any surface, and into the shadow maps of the camera's lights (Bevy's shader_advanced/deferred_raymarch).

Rust: raea_sys_phase::GBufferPass.

Used in: shader_advanced/deferred_raymarch.

#Gizmo

Debug lines drawn by Bevy's gizmo renderer (a retained bevy_gizmos Gizmo and its GizmoAsset), placed like a part: a path, a bounding box, an axis, a ray. They cast and take no light, and draw over nothing unless depthBias says.

Bevy: bevy_gizmos::retained::Gizmo.

Takes GizmoProps's props.

Used in: shader_advanced/render_depth_to_texture.

#Goo

Objects melting into goo: the bake drawn by the frame (nothing before from).

#Grade

The camera's colour grade (lift, gamma, gain and saturation per range of light, before tone mapping), a lens vignette and colour fringes: one grade over every scene, so a film looks of a piece. Put it inside the Canvas3D.

Bevy: bevy_render::view::ColorGrading, bevy_post_process::effect_stack::chromatic_aberration::ChromaticAberration, bevy_post_process::effect_stack::vignette::Vignette.

Takes GradeProps's props.

#Grass

A field of grass over area, made by the engine from the ground's functions (sampled once at resolution).

#ImagePlane

A picture on a flat card in the scene, unlit (a poster, a screen, a sprite).

Bevy: bevy_image::image::Image.

Takes ImagePlaneProps's props.

#Instances

One glTF (or one mesh) drawn at many placements, loaded once and drawn by the GPU as instances: a meadow's grass and flowers, a forest, a suburb's houses. <Instances src={staticFile("daisy.glb")} at={scatter({...})} />. The copies share one surface and can't play a clip.

Bevy: bevy_pbr::render::mesh::MeshPipeline (automatic batching of entities sharing a mesh and material).

Takes InstancesProps's props.

#LensDistortion

Barrel or pincushion distortion (Brown-Conrady k1, k2) on the camera, a pass after tone mapping as Fisheye's. Put it inside the Canvas3D.

Bevy: bevy_post_process::LensDistortion.

Takes LensDistortionProps's props.

#Look

The whole frame drawn as a model's look draws its model: every part of the scene in the one grain, its bloom, fog and blur inside it. Put it inside the Canvas3D. mode="paint" or "cartoon" draws every standard material as paint (engine/render paint.rs):

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<bevy_pbr::extended_material::ExtendedMaterial<bevy_pbr::pbr_material::StandardMaterial, raea_render::engine::paint::Paint>>.

Takes LookProps's props.

#Matchmove

Footage with real 3D standing in it: the clip behind, its camera solved and followed, the subject in front. Fills the frame (its camera's view is the frame's); its children are the 3D in the shot's world, lights included.

Takes MatchmoveProps's props.

#MeshPass

The mesh it's inside drawn again by your shader, in a phase of its own after the camera's main opaque pass: onto the colour target, with no depth test unless depth, back faces culled (Bevy's shader_advanced/custom_render_phase). It reads the mesh's colours at location 1 under VERTEX_COLORS when the mesh has them.

Rust: raea_sys_phase::MeshPass.

Used in: shader_advanced/specialized_mesh_pipeline, shader_advanced/custom_render_phase.

#MeshSequence

A baked simulation, one mesh a frame.

Takes MeshSequenceProps's props.

#MeshShaderPass

Inside a Camera3d: your task and mesh shaders make primitives on the GPU and your fragment shader draws them into the view's colour and depth (compared GreaterEqual) after the main opaque pass (Bevy's shader_advanced/mesh_shader_intro). It needs a GPU with mesh shaders, as Apple silicon's Metal has; elsewhere it draws nothing and says so.

Rust: raea_sys_phase::MeshShaderPass.

Used in: shader_advanced/mesh_shader_intro.

#Model

A glTF model. Its clips are the file's (@bevy bevy_animation::AnimationClip), played by animation, blended by animations or composed by graph, each built by the engine into its AnimationGraph (@bevy bevy_animation::graph::AnimationGraph; engine/render scene3d.rs). look draws the model in its own grain (engine/render look.rs):

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<raea_render::engine::look::LookMaterial>.

Used in: 3d/lightmaps, 3d/split_screen, 3d/atmospheric_fog, stress_tests/many_foxes, camera/projection_zoom, animation/animated_mesh, gltf/gltf_skinned_mesh, gltf/load_gltf, and 1 more.

#MotionBlur

Motion blur from each part's and the camera's motion over the frame before (Bevy's MotionBlur): with it, each frame is drawn after the one before it, so a frame's blur is the same in a render, a seek and play. A frame without it has none. Put it inside the Canvas3D.

Bevy: bevy_post_process::motion_blur::MotionBlur.

Takes MotionBlurProps's props.

#Outline

Ink lines where the scene's depth steps or its surfaces turn, drawn before bloom and tone mapping; under a a cell wide (Return of the Obra Dinn's line). Put it inside the Canvas3D.

Takes OutlineProps's props.

#Part

A glTF's nodes drawn on their own, where they stood, moved by a rigid motion, glitched by the frame's values.

#PhaseItem

Your own pipeline drawing your own buffers in each camera's Opaque3d phase.

Rust: raea_sys_phase::PhaseItem.

Used in: shader_advanced/custom_phase_item.

#Physics

Rigid bodies, simulated once and played back by the frame: the s among its children (directly, or in fragments). Before from and after seconds they hold their first and last poses.

#Plane3d

From Bevy's bevy_shape::Plane3d: A bounded plane in 3D space. It forms a surface starting from the origin with a defined height and width.

Takes Plane3dProps's props.

#Plate

Footage behind the 3D: the clip's frame filling the camera's whole view (its view when it has one), on the far side of everything, unlit. Give the scene <ToneMapping mode="none" /> to keep its colours exact. is the usual way in.

Takes PlateProps's props.

#Refinish

Every inside re-covered: each of its glTF materials (all, or the one each names by material) given the colour, texture or finish each gives, the rest of it kept (a run of cabinets painted, the doors and drawers with them; map: null takes the wood's picture off). A model's own children go first.

#RichText

Text in the 3D world: every glyph a real lit, shaded entity (bevy_rich_text3d's mesh over its glyph atlas, a StandardMaterial of its own), laid out as one line of shaped text (kerning, spans of other fonts and sizes) and then moved, turned, scaled, recoloured, faded and revealed glyph by glyph with the motion code 2D uses: the named moves staggered (enter="rise" each={2}), a typewriter's reveal, or a glyph function of the frame.

Hello world <RichText glyph={(g) => ({ position: [0, Math.sin(frame / 6 + g.index) * 0.05, 0] })}>WAVE

Takes RichTextProps's props.

#Scene

A world drawn at the current frame: its mesh rows (shape, x y z, rot_x rot_y rot_z in radians, scale, color, rough, metal), camera (x y z, look_x look_y look_z, fov), light (x y z, intensity) and ambient (intensity) rows as the 3D elements above. Inside a Canvas3D.

#Screen

A live picture on a surface in the 3D scene: a nested composition or game (its children, or src, a video) at its own resolution, drawn as a CRT (scanlines, mask, glow, the glass) or flat. Inside a Canvas3D on its own it's a free-standing quad; on a model, give it to the Model: <Model src={...} screens={{ monitor_screen: <Screen resolution={[384, 272]}><Game /></Screen> }} />. A screen doesn't light the room: put a dim light of its colour in front of it.

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<raea_render::engine::screen::CrtMaterial>.

Also takes the props of ScreenSource.

#ShaderInstances

The mesh it's inside drawn once per instance in one draw, by your shader, in the camera's Transparent3d phase, a vertex buffer of your words stepped per instance (Bevy's shader_advanced/custom_shader_instancing). Its instances aren't in the mesh's bounds: give the mesh Bevy's NoFrustumCulling ().

Rust: raea_sys_phase::ShaderInstances.

Used in: shader_advanced/custom_shader_instancing.

#ShaderMesh

A mesh drawn by a material written here in WESL or WGSL: one generic Bevy material (rdb's ShaderMaterial, an AsBindGroup of 16 uniform slots and 4 textures) whose fragment shader is this source, so a dissolve, a toon ramp, a hologram or a procedural pattern needs no Rust. Uniforms may change from frame to frame (they're set again on any frame where they change); the shader isn't compiled again (#28).

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<raea_sys_material::shader_material::ShaderMaterial>.

Takes ShaderMeshProps's props.

#Shadows

Shadow quality for every light in the Canvas3D: map size, the sun's cascades, biases, filtering. Put it inside the Canvas3D, once; the first frame's holds for the piece. mapSize sets both shadow maps' size, filter the camera's filtering, and the cascade props the sun's cascades (engine/render scene3d.rs):

Bevy: bevy_light::directional_light::DirectionalLightShadowMap, bevy_light::point_light::PointLightShadowMap, bevy_light::ShadowFilteringMethod, bevy_light::cascade::CascadeShadowConfig.

Takes ShadowsProps's props.

Used in: 3d/shadow_caster_receiver, 3d/atmospheric_fog, gltf/load_gltf, shader_advanced/deferred_raymarch.

#Shape2D

A flat shape in 2D, over the 3D, in one colour: Bevy's Mesh2d with a ColorMaterial (raea-sys-sprite). Put it inside the Canvas3D.

Bevy: bevy_sprite_render::mesh2d::color_material::ColorMaterial, bevy_sprite_render::mesh2d::material::MeshMaterial2d<bevy_sprite_render::mesh2d::color_material::ColorMaterial>, bevy_mesh::components::Mesh2d.

Takes Shape2DProps's props.

#Skybox

Bevy's Skybox: a cubemap drawn behind everything, as Bevy's examples put one on the camera. Put it inside the Canvas3D, once; its brightness and rotation may change each frame (an 's background is the sky of a panorama raea filters).

Bevy: bevy_light::probe::Skybox.

Takes SkyboxProps's props.

#Span

A run of a 's text in its own font, weight, size or colour. Only inside a .

Takes SpanProps's props.

#Sphere

Also takes the props of SphereProps (args, radius, ico, uv).

Used in: 3d/bloom_3d.

#Splat

A gaussian splat: a reconstructed scene or object, drawn back to front for the frame's camera, behind any mesh in front of it, through the frame's look. Animate it with reveal, assemble, disperse, explode, wave, twist, morph and pulse, all values of the frame.

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<raea_render::engine::splat::SplatMaterial>, bevy_pbr::mesh_material::MeshMaterial3d<raea_render::engine::splat::SplatMask>.

Takes SplatProps's props.

#Sprite

A picture in 2D, over the 3D: Bevy's Sprite, drawn as a quad with its sprite material, a sprite sheet's cells cut by a texture atlas (raea-sys-sprite). Put it inside the Canvas3D.

Bevy: bevy_sprite::sprite::Sprite, bevy_sprite_render::sprite_mesh::sprite_mesh_material::SpriteMeshMaterial, bevy_sprite_render::mesh2d::material::MeshMaterial2d<bevy_sprite_render::sprite_mesh::sprite_mesh_material::SpriteMeshMaterial>, bevy_sprite_render::sprite_mesh::sprite_extended_material::SpriteMaterial, bevy_image::texture_atlas::TextureAtlasLayout.

Takes SpriteProps's props.

Used in: camera/pan_camera_controller, camera/2d_on_ui, shader/compute_shader_game_of_life, shader/sprite_material, 2d/rotation, 2d/move_sprite, 2d/sprite_slice, 2d/rotate_to_cursor, and 8 more.

#SurfaceShader

One shader over every lit standard surface in the scene that has none of its own (meshes, Models' materials, Characters), so the whole scene shares one look. Unlit, toon, paint, flat and looked surfaces and ShaderMesh keep theirs. In the 3D beside the camera; one per scene.

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<bevy_pbr::extended_material::ExtendedMaterial<bevy_pbr::pbr_material::StandardMaterial, raea_sys_shader::ShaderExt>>.

Takes SurfaceShaderSpec's props.

#Text3D

Solid 3D letters (Manifold's text3d), as a Mesh's geometry: <Mesh><Text3D size={0.6}>SALE</Text3D>...</Mesh>.

Takes Text3DProps's props.

#ThreeShaderMaterial

A three.js shader on the mesh it's in, as it is: a ShaderMaterial's GLSL (or a node material's WGSL) with its uniforms, drawn by raea's engine with three's built-ins. <R3F> makes these from an R3F scene's materials.

Takes ThreeShaderMaterialProps's props.

#ToneMapping

The camera's tone mapping and exposure. Put it inside the Canvas3D.

Bevy: bevy_render::view::Tonemapping, bevy_camera::camera::Exposure.

Takes ToneMappingProps's props.

Used in: 3d/rotate_environment_map, 3d/bloom_3d, 3d/mesh_ray_cast.

#Torus

From Bevy's bevy_shape::Torus: A torus primitive, often representing a ring or donut shape The set of points some distance from a circle centered at the origin

Also takes the props of TorusProps (args, major_radius, minor_radius).

#Volume

A simulated volume: density and heat in a box, put in by its sources and puffs, lifted by heat, weighed down, carried by the wind and its own curls, drawn lit and shadowed by itself. Smoke, a cloud or a contrail is a choice of these (examples/volumes). Simulated and raymarched by engine/render volume.rs:

Bevy: bevy_pbr::mesh_material::MeshMaterial3d<raea_render::engine::volume::VolumeMaterial>.

Takes VolumeProps's props.

#VolumetricFog

Volumetric fog on the camera: light in the air, drawn inside every , with shafts from the lights marked volumetric. Put it inside the Canvas3D, once; without it fog volumes draw nothing.

Bevy: bevy_light::volumetric::VolumetricFog, bevy_light::volumetric::VolumetricLight.

Takes VolumetricFogProps's props.

#ZFight

The part drawn twice in the same place, the second a hair turned, in another material: the two surfaces fight for the depth buffer and flicker in stripes (z-fighting), stronger with amount (radians, ~0.002).

Also takes the props of PartProps.

#Hooks

#useBake

The bake for these props (made once and kept).

function useBake(props: PhysicsProps): Baked

#useGoo

The goo's bake for these props (made once and kept), and the frame (of the enclosing Sequence) at which each object's own part should go, the goo having taken it over.

function useGoo(p: GooProps): GooBake & { gone: (name: string) => boolean; frame: number; }

#useMatchmove

The solve and this frame's camera, inside a .

function useMatchmove(): MatchmoveState

#usePhysics

Inside : the bake and the frame in it.

function usePhysics(): { baked: Baked; frame: number; t: number; }

#Functions

#about

A rigid motion of a part about a point (about, its rest centre): turn by q there, then move by move. As a / position and quaternion.

function about(about: Vec3, q: Quat, move?: Vec3): { position: Vec3; quaternion: Quat; }

#bodyPose

A body's rigid motion from rest at the current frame.

function bodyPose(baked: Baked, name: string, k: number): { position: Vec3; quaternion: Quat; }

#checkMatchmove

Checks a Matchmove's props; throws a TypeError or RangeError naming the prop.

function checkMatchmove(p: MatchmoveProps): void

#checkPass

A part's composition pass, checked: a name, letters first (up to 32 of letters, digits, _ and -).

function checkPass(owner: string, pass: unknown): void

#clipEvents

The clip events that fire between two frames (Bevy's AnimationClip events, as data): an event time seconds into the clip fires on the frame whose clip time first reaches it, that is when it lies in (prev, now], once per loop when the clip loops (duration its length). Give the previous frame's clip time and this frame's, as a 's time runs; on the first frame pass prev -1 so an event at 0 fires.

function clipEvents<E extends { time: number; }>(events: E[], prev: number, now: number, duration: number, loop?: boolean): E[]

#dofOf

Bevy's DepthOfField fields as the old ones; their defaults are Bevy's (f/1, where the old one is f/2.8)

function dofOf(owner: string, props: DepthOfFieldProps): DepthOfFieldProps

#eulerOf

A part's Euler angles of a quaternion: a composition's rotation [x, y, z] is composed as three.js composes it, Quat::from_euler(EulerRot::XYZ, x, y, z) (runtime/scene local; the YXZ rot_x/rot_y/rot_z of raea-render's rows are read back from the world matrix), so this is that order's inverse.

function eulerOf(q: [number, number, number, number]): Vec3

#gooSpec

The spec tools/goo bakes for these props at the composition's fps: what physics goo SPEC.json takes, and the bake's key, so a script can bake (or check) a goo without rendering.

function gooSpec(p: GooProps, fps: number): Record<string, unknown>

#hash01

0..1 from integers, the same on every run

function hash01(...xs: number[]): number

#lastBeat

The last of times at or before t: its index (-1 before the first) and how long ago it was, seconds.

function lastBeat(t: number, times: readonly number[]): { index: number; since: number; time: number; }

#matchmoveIndex

The solve's frame at a time in the clip: the latest at or before it, clamped to the solve.

function matchmoveIndex(solve: MatchmoveSolve, time: number): number

#matchmoveView

The footage's view in a frame of another shape: the whole view's size (the footage scaled to cover the frame, times zoom) and the frame's window in it, in frame pixels.

function matchmoveView(footage: { width: number; height: number; }, frame: { width: number; height: number; }, crop?: number | [number, number], zoom?: number): { width: number; height: number; x: number; y: number; }

#part

glTF nodes cut out as their own file, standing where they stood (made once, kept in the asset store).

function part(src: string, nodes: string[], material?: PartMaterial): PartInfo

#physicsRequest

The simulation's request: every body's props as Rapier takes them, events in frames.

function physicsRequest(props: PhysicsProps, fps: number): Record<string, unknown>

#pick

The nearest part under the pointer, or null. size is the frame's (useVideoConfig's width and height), whose pixels the pointer is in.

function pick(pointer: { x: number; y: number; }, camera: PickCamera, parts: readonly Pickable[], size: { width: number; height: number; }): Hit | null

#place

function place(o: { objects: Record<string, V3 | PlaceObject>; rules: PlaceRule[]; room?: { min: [number, number]; max: [number, number]; } | undefined; }): Layout

#pointerRay

The pointer's ray: from the camera through the pointer (x, y in the frame's pixels, y down), as the engine draws it (Bevy's looking_at, with +Z for up when the camera looks straight up or down, as rdb does).

function pointerRay(pointer: { x: number; y: number; }, camera: PickCamera, size: { width: number; height: number; }): { origin: Vec3; direction: Vec3; }

#quatAxis

The quaternion [x, y, z, w] turning angle radians about axis, as Bevy's Quat::from_axis_angle.

function quatAxis(axis: Vec3, angle: number): Quat

#quatMul

The product a × b of two quaternions [x, y, z, w], b applied first, as Bevy's Quat * Quat.

function quatMul(a: Quat, b: Quat): Quat

#samplerSpec

A sampler checked (a TypeError or RangeError naming the owner and the part).

function samplerSpec(owner: string, s: SamplerSpec): SamplerSpec

#scatter

Points scattered over an area for an : seeded (the same layout every frame and every run), at least spacing apart, clear of avoid and clearOf, on the ground y gives, kept by density. A spatial hash keeps thousands quick. Call it once at module level, not per frame.

function scatter(o: ScatterOptions): Instance[]

#snapPose

Positions snapped to a grid (step metres): a physics engine's position quantised.

function snapPose(p: Vec3, step: number): Vec3

#surfaceShader

A surface shader checked and given as the row's spec (its source, uniforms, textures).

function surfaceShader(owner: string, sh: SurfaceShaderSpec, hook?: RegExp, hooks?: string): Record<string, unknown>

#surfaceTurn

The turn that takes +y to normal, with the picture's top (a decal's -z) toward world up on a wall, toward -z on a floor, turned spin about the normal: a quaternion [x, y, z, w].

function surfaceTurn(normal: Vec3, spin?: number): [number, number, number, number]

#teleport

A position that jumps to a new seeded spot on each beat in times (within radius, metres, on the axes axes scales) and holds it, back home hold seconds after the beat (Infinity: until the next).

function teleport(t: number, times: readonly number[], o: { radius: number; seed?: number; hold?: number; axes?: Vec3; }): Vec3

#toHex

A colour as the 3D renderer takes it (#rrggbb): hex, rgb()/rgba() or a common name; CSS variables throw.

function toHex(owner: string, k: string, v: unknown): string

#Classes

#CrossSection

A 2D shape (Manifold's CrossSection), held by value: its contours (counter-clockwise solid, clockwise holes), area and bounds. Offset, combine and move it, then extrude or revolve it into a Solid.

#Field

A signed distance field (negative inside), as the text raea-core-sdf reads. Y is up; sizes are metres.

#Solid

A handle to a native solid. Free it when done with many (or let the run end).

#Values

#ATTRIBUTE_COLOR

Bevy's Mesh::ATTRIBUTE_COLOR: a vertex's linear RGBA colour (id 5, Float32x4)

#ATTRIBUTE_NORMAL

Bevy's Mesh::ATTRIBUTE_NORMAL: a vertex's normal (id 1, Float32x3)

#ATTRIBUTE_POSITION

Bevy's Mesh::ATTRIBUTE_* (ids 0 to 5), as a Material's vertex buffer names them.

#ATTRIBUTE_TANGENT

Bevy's Mesh::ATTRIBUTE_TANGENT: a vertex's tangent, its w the bitangent's sign (id 4, Float32x4)

#ATTRIBUTE_UV_0

Bevy's Mesh::ATTRIBUTE_UV_0: a vertex's first texture coordinates (id 2, Float32x2)

#ATTRIBUTE_UV_1

Bevy's Mesh::ATTRIBUTE_UV_1: a vertex's second texture coordinates, as a lightmap's (id 3, Float32x2)

#crossSection

2D shapes as CrossSections, made natively.

#grow

Generated growth as Solids, built natively: tree, loft, terrain, boulder, rosette and the rest. Draw one with <Mesh shape={solid}>; cut, join, measure and place it like any other Solid.

#manifold

#MeshVertexAttribute

A vertex attribute: its name, its unique id (a high random one for your own, as Bevy asks, so it sorts after the built-in ones) and its format. MeshVertexAttribute.new("BlendColor", 988540917, "Float32x4") is Bevy's MeshVertexAttribute::new; Mesh's own are ATTRIBUTE_POSITION and the rest.

Bevy: bevy_mesh::MeshVertexAttribute.

#outline

2D outlines for extrude and revolve.

#sdf

#Types

#AlphaMode2d

bevy_sprite_render's AlphaMode2d

type AlphaMode2d = "Opaque" | "Blend" | { Mask: number }

#AmbientOcclusionProps

#Animate3d

A 3D node's declared animation: tracks by property, or a move.

type Animate3d = Record<string, TrackSpec | TrackSpec[] | Keys> | Move

#AnimGraphNode

A node of a .

type AnimGraphNode = | { clip: string | number; time?: number; weight?: number; mask?: string[] } | { blend: AnimGraphNode[]; weight?: number; mask?: string[] } | { add: AnimGraphNode[]; weight?: number; mask?: string[] }

#AntiAliasingProps

#AtmosphereProps

#Baked

#BevyComponentProps

The props of BevyComponent, tabled there.

#BevyParts

What a light or camera holds: Bevy's own reflected components on it (, or a generated wrapper such as bevy_light's ShadowFilteringMethod or bevy_pbr's ScreenSpaceReflections), applied through Bevy's TypeRegistry.

#BloomProps

#BodyProps

The props of Body, tabled there.

#Bounds

#BufferMeshProps

#Canvas3DProps

#Capsule3dProps

Bevy's Capsule3d: radius and half_length, the straight part's half (0.5 each by Bevy's default), standing up.

#CapsuleProps

#ComputeProps

A compute shader (raea-sys-compute). Its source has one @compute entry point and reads time() (seconds), u_NAME() for each uniform, each buffer as NAME: array<f32> (read and written) and each image as NAME: texture_storage_2d<rgba8unorm, write>.

#ConeProps

#CrtSettings

How the tube draws the picture. Every value is optional; crt={false} on the Screen draws it flat and sharp.

#CuboidProps

Bevy's Cuboid: half its size along each axis ([0.5, 0.5, 0.5], a 1 m cube, as Bevy's default).

#CylinderProps

args, or Bevy's Cylinder fields: radius and half_height (0.5 each by Bevy's default).

#DecalProps

#DepthCopyProps

The props of DepthCopy, tabled there.

#DepthOfFieldProps

#EntityProps

The props of Entity, tabled there.

#EnvironmentMapLightProps

#EnvironmentProps

#FireProps

#FisheyeProps

#FogColor

a fog colour: "#rrggbb" (or #rrggbbaa), or Bevy's Srgba or LinearRgba (raea/color)

type FogColor = string | { red: number; green: number; blue: number; alpha: number }

#FogFalloff

bevy_pbr's FogFalloff as it reflects; FogFalloff's constructors (raea/pbr) make one from a visibility distance

type FogFalloff = | { Linear: { start: number; end: number } } | { Exponential: { density: number } } | { ExponentialSquared: { density: number } } | { Atmospheric: { extinction: [number, number, number]; inscattering: [number, number, number] } }

#FogProps

#FogVolumeProps

#FramePassProps

A shader over the whole frame. Its source defines fn shade(in: FullscreenVertexOutput) -> vec4 (or its own

#GBufferPassProps

The props of GBufferPass, tabled there.

#GizmoColor

a gizmo point's colour: "#rrggbb", linear [r, g, b, a], or Bevy's LinearRgba / Srgba (bevy3d's colours)

type GizmoColor = string | [number, number, number, number] | { red: number; green: number; blue: number; alpha?: number }

#GizmoProps

#Glitch

#GlyphInfo

What a glyph is, for a 's glyph function.

#GlyphStyle

A glyph's motion this frame, about its own centre, in the block's space: added to (position, rotation), multiplied into (scale, opacity) or replacing (color, visible) what the block's moves give it.

#GooBake

#GooObject

#GooProps

The props of Goo, tabled there.

#GradeProps

#GradeSection

#GrassLod

One step of detail: tiles nearer than to metres draw keep of their clumps (0 to 1), each with its first blades blades in segments segments, widen times as wide.

#GrassProps

The props of Grass, tabled there.

#Hit

#ImagePlaneProps

#Impulse

#Instance

One copy's placement in an , in the Instances' own space (its position, rotation and scale move every copy together). Rotation in radians, XYZ order, as everywhere.

#InstancesProps

#Layout

type Layout = Record<string, Placed> & { readonly found: PlaceFinding[]; readonly errors: number }

#LensCommon

#LensDistortionProps

#LoftOutline

type LoftOutline = string | [number, number][]

#LookPass

One composition pass's own paint (): the frame's rag, grain and palette, and its surfaces' bands, torn shadow edge, strokes, saturation and wash; what it leaves out is the Look's.

#LookProps

#MatchmoveCamera

#MatchmoveProps

#MatchmoveSolve

What raea track writes and draws from.

#MatchmoveState

Each frame's state under a , for the 3D inside it.

#MeshAttribute

One attribute's values on a mesh: one a vertex, each a number or a list of the format's size.

type MeshAttribute = [MeshVertexAttribute, (number | number[])[]]

#MeshPassProps

The props of MeshPass, tabled there.

#MeshSequenceProps

#MeshShaderPassProps

The props of MeshShaderPass, tabled there.

#MeshSlab

A mesh's vertex or index buffer in Bevy's MeshAllocator, bound as a file's storage buffer (array<f32 | u32 | i32>) for its compute to write (shader_advanced/compute_mesh): the mesh the part named mesh holds, a with indices and normals (position, normal and uv interleaved, 8 floats a vertex).

Bevy: bevy_render::mesh::allocator::MeshBufferSlice.

#ModelProps

The props of Model, tabled there.

#ModelScreens

A Model's screens prop: each material's screen, as a element (its props and children) or a bare composition element (a of the defaults around it).

type ModelScreens = Record<string, ReactElement>

#MotionBlurProps

#OutlineProps

#PartInfo

#PartMaterial

#PartProps

The props of Part, tabled there.

#PhaseAttribute

A vertex attribute: Bevy's VertexFormat by name, its byte offset in a vertex and its shader

#PhaseItemProps

The props of PhaseItem, tabled there.

#PhysicsProps

The props of Physics, tabled there.

#Pickable

Something the pointer can hit: an axis-aligned box or a sphere, in world space.

type Pickable = { name: string; box: { min: Vec3; max: Vec3 } } | { name: string; sphere: { center: Vec3; radius: number } }

#PickCamera

The camera as a scene sets it: a PerspectiveCamera's props (fov in degrees, vertical) or an OrthographicCamera's.

#Place2dProps

Where a 2D part is: composition px from the frame's top left, y down (as the page's), its centre there; and its pointer and drag handlers, called as a 3D part's are (2D parts are picked first, the top one by z).

#Placed

#PlaceFinding

#PlaceObject

#PlaceRule

type PlaceRule = | { on: string; of: string } | { against: string; wall: Side } | { beside: string; of: string; side: Side; gap?: number } | { near: string; of: string; dist?: number } | { apart: string; of: string; min?: number } | { facing: string; of: string } | { align: string; of: string; axis: "x" | "z" } |…

#PlanBox

A box on the plan (x, z, metres): the room SDK's Footprint, or any { min, max }.

#Plane3dProps

Bevy's Plane3d: a flat rectangle facing normal (Bevy's default +Y, a floor), half_size its half extent along its two axes ([0.5, 0.5]), laid out as Bevy's PlaneMeshBuilder does: facing +Z it is a Plane of args [2 x half_size]. The normal is along an axis; a tilted plane is a rotated Mesh3d.

#PlateProps

#Polygons

A 2D outline: contours of [x, y] points (counter-clockwise for solid, clockwise for a hole).

type Polygons = [number, number][][]

#RichTextProps

#SamplerSpec

How a texture is read (Bevy's ImageSamplerDescriptor; raea-sys-sampler). Each part is optional, over the texture's own default. A texture file loaded with two samplers is drawn with the last (the load says so).

#SamplerWrap

type SamplerWrap = "repeat" | "clamp" | "mirror"

#ScatterOptions

#SceneProps

The props of Scene, tabled there.

#ScreenProps

The props of Screen, tabled there.

#ScreenSource

#Section

A cross-section of a solid at a height: its area, how many contours, and the contours themselves.

#ShaderInstancesProps

The props of ShaderInstances, tabled there.

#ShaderMeshProps

#ShadowsProps

#Shape

type Shape = "hull" | "box" | "mesh" | { box: Vec3 } | { sphere: number } | { capsule: [number, number] }

#Shape2DProps

#SkyboxProps

#SpanProps

#SphereProps

args, or Bevy's Sphere field: radius (0.5 by Bevy's default). Its mesh is Bevy's Sphere::mesh(): an icosphere of 5 subdivisions, or ico of them (Bevy's .ico(n), 0 to 80), or a UV sphere of uv = [sectors, stacks] (.uv(s, t)).

#SplatMorph

#SplatProps

#SplatWave

#SpriteProps

#SurfaceDrawProps

How a surface's alpha and faces draw (Bevy's StandardMaterial alpha_mode, alpha cutoff, double_sided and cull_mode), from the first frame.

#SurfaceShaderSpec

#Text3DProps

#ThreeShaderMaterialProps

#ThreeUniform

A uniform's value: a number, a boolean, or its numbers in order (a vector's, a matrix's column by column as three's elements, an array's elements one after another)

type ThreeUniform = number | boolean | number[]

#ToneMappingProps

#ToonBand

#ToonHighlight

#ToonOutline

#ToonRim

#TorusProps

args, or Bevy's Torus fields: major_radius (0.75) and minor_radius (0.25), the tube's.

#TreeOptions

#Vec3

type Vec3 = [number, number, number]

#VertexFormat

A vertex attribute's format, as Bevy's VertexFormat names it.

type VertexFormat = "Float32" | "Float32x2" | "Float32x3" | "Float32x4" | "Uint32" | "Uint32x2" | "Uint32x3" | "Uint32x4" | "Sint32" | "Sint32x4"

#VolumeCommon