weft_graphics

pub fn angle_from_top(dx: f32, dy: f32) -> f32

Clockwise angle in degrees from 12 o'clock of the vector (dx, dy) (screen coordinates, y down), in 0..360.

pub fn catmull_rom(points: &[(f32, f32)]) -> Vec<DrawCommand>

Cubic Bézier segments for a Catmull-Rom spline through points (the caller emits the initial MoveTo).

pub fn custom_fragment(body: &str) -> String

Wrap user GLSL (which must define main writing out_color) with the standard uniforms and helpers.

pub fn custom_mesh_program(vertex: Option<&str>, fragment: &str) -> (String, String)

The vertex and fragment sources for a custom mesh material. A source with its own #version is used as it is; otherwise it gets the prelude: the standard attributes (a_position, a_normal, a_uv, a_color), uniforms (u_size — the mesh's own size in world units — u_mvp, u_model, u_view, u_projection, u_normal_matrix, u_time, u_resolution, u_camera, u_color, u_opacity, u_map, the lights), snoise(vec3), and in fragments weft_lambert(n, world), weft_lin, weft_gamma and out_color. With no vertex source, CUSTOM_DEFAULT_VERTEX passes v_uv, v_normal, v_world, v_position and v_color on.

pub fn deg_to_rad(deg: f32) -> f32

Degrees to radians.

pub fn directional_shadow_matrix(direction: Vec3, casters: &[Bounds], receivers: &[Bounds]) -> Option<Mat4>

The key light's shadow view-projection: an orthographic box looking along direction (which points towards the light), fitted around casters and deep enough to reach receivers. None without casters.

pub fn display_list(shapes: &[Shape], width: f32, height: f32) -> Vec<DrawCommand>

Full frame: clear, then each shape inside its own save/restore.

pub fn distance_to_segment(p: (f32, f32), a: (f32, f32), b: (f32, f32)) -> f32

Shortest distance from p to the segment a–b.

pub fn ease_in_out_cubic(t: f32) -> f32

Cubic ease-in-out of t (0 to 1).

pub fn ease_out_cubic(t: f32) -> f32

Decelerating curve, clamped to 0..=1.

pub fn hit_test(shapes: &[Shape], x: f32, y: f32) -> Option<usize>

Index of the topmost (last drawn) shape containing the point.

pub fn joint_bounds(mesh: &Mesh) -> Vec<Option<Bounds>>

For a skinned mesh, each joint's box around the (bind-pose) vertices it moves (None for joints that move none). See skinned_bounds.

pub fn layout_text(glyphs: &dyn Glyphs, font_key: &str, spec: &TextSpec, cache: &mut HashMap<String, Mesh>) -> Mesh

spec's text as one mesh, in scene units (size per em), aligned per align with its first baseline at y = 0 and lines going down. Glyph meshes are cached in cache by font and settings.

pub fn lerp(a: f32, b: f32, t: f32) -> f32

The value t of the way from a to b.

pub fn point_in_polygon(p: (f32, f32), poly: &[(f32, f32)]) -> bool

Even-odd point-in-polygon test.

pub fn point_shadow_faces(position: Vec3, near: f32, far: f32) -> [Mat4; 6]

A point light's six cube-face view-projections, in GL's cube-map face order and orientation (+X, −X, +Y, −Y, +Z, −Z).

pub fn preset_fragment(name: &str) -> Option<&'static str>

A preset's body (void main() and its helpers), as a mesh material's fragment shader (shaderMaterial(preset: "aurora")).

pub fn preset_source(name: &str) -> Option<String>

Complete fragment shader for a preset.

pub fn shadow_far(position: Vec3, boxes: &[Bounds]) -> f32

How far a light at position must see to reach every box.

pub fn shadow_near(far: f32) -> f32

The near plane for a perspective shadow map reaching far.

pub fn skinned_bounds(joint_bounds: &[Option<Bounds>], joints: &[f32], model: &Mat4) -> Option<Bounds>

Where a skinned mesh is, posed: each joint's joint_bounds box moved by its joint matrix (16 floats each, as [crate::Model::joint_matrices] gives them), then by model. Every posed vertex is a blend of its joints' moves, so it lies inside. None without joint boxes.

pub fn slerp(a: [f32; 4], b: [f32; 4], t: f32) -> [f32; 4]

Spherical linear interpolation between unit quaternions.

pub fn spot_shadow_matrix(spot: &SpotLight, far: f32) -> Mat4

A spot light's shadow view-projection: a perspective frustum just wider than its cone, reaching far.

pub fn uniform_identifiers(src: &str) -> Vec<String>

Every u_* identifier in a shader, sorted and de-duplicated.

pub fn world_bounds(local: Bounds, m: &Mat4) -> Bounds

The world-space box around local (a box in an object's own space) placed by m.

pub const ATTR_COLOR: u32 = 3;

Per-vertex rgba (white when a mesh has none).

pub const ATTR_JOINTS: u32 = 4;

Skinning: four joint indices and four weights per vertex.

pub const ATTR_NORMAL: u32 = 1;

Where vertex normals go.

pub const ATTR_POSITION: u32 = 0;

Where vertex positions go in the mesh shaders.

pub const ATTR_SEED: u32 = 1;

Per-particle (phase, size, color mix) attribute (shares location 1).

pub const ATTR_UV: u32 = 2;

Where texture coordinates go.

pub const ATTR_WEIGHTS: u32 = 5;

Skinning weights: four per vertex, for the joints in ATTR_JOINTS.

pub const CUSTOM_DEFAULT_VERTEX: &str = …;

The vertex shader a custom material gets when it has none.

pub const FRAGMENT_HEADER: &str = …;

Declarations and helpers shared by every preset and custom fragment.

pub const FRAGMENT_SHADER: &str = MESH_FRAGMENT;

Back-compat alias for the lit mesh program's fragment shader.

pub const FULLSCREEN_VERTEX: &str = …;

Full-screen triangle with no vertex buffers (drawArrays(TRIANGLES, 0, 3)).

pub const MAX_POINT_LIGHTS: usize = 4;

How many point lights the renderer supports.

pub const MAX_SPOT_LIGHTS: usize = 4;

How many spot lights the renderer supports.

pub const MESH_FRAGMENT: &str = …;

Lit mesh fragment shader: hemisphere ambient + Blinn-Phong key, point and spot lights (with shadows) + Fresnel rim + emissive, optional vertical color gradient and fog, ACES tone mapping in linear space.

pub const MESH_VERTEX: &str = …;

Lit mesh vertex shader. With u_wobble > 0 vertices are displaced along their normals by animated 3D simplex noise (Ashima Arts, MIT) and normals are recomputed by finite differences.

pub const PARTICLE_FRAGMENT: &str = …;

The fragment shader for 3D particles.

pub const PARTICLE_VERTEX: &str = …;

The vertex shader for 3D particles.

pub const PBR_FRAGMENT: &str = …;

Physically based fragment shader (metallic-roughness): GGX distribution, height-correlated Smith visibility and Schlick Fresnel for the key, point and spot lights (with shadows); the hemisphere ambient as diffuse light and, along the reflection, as a blurred environment (Karis's analytic split-sum approximation). Normal maps use tangents from screen-space derivatives, so meshes need no tangents.

pub const PRESETS: &[&str] = _;

Preset names, usable as shader(preset: …) and scene3d(backdrop: …).

pub const SHADOW_FRAGMENT: &str = …;

Shadow-map depth pass: MESH_VERTEX (so skinning and wobble move shadows too) with a fragment shader that only writes depth.

pub const VERTEX_SHADER: &str = MESH_VERTEX;

Back-compat aliases for the lit mesh program.

pub type Bounds = (Vec3, Vec3);

An axis-aligned box, (min, max).