Struct ParticleGradient 

pub struct ParticleGradient(/* private fields */);

A piecewise linear RGBA gradient, interpolated in the supplied color space.

use ponko::*;
let g = ParticleGradient::new(vec![(0.0, Color::WHITE), (1.0, Color::BLACK)]);
assert_eq!(g.sample(0.5).r, 0.5);

Implementations

impl ParticleGradient

pub fn new(keys: Vec<(f32, Color)>) -> Self

Creates a gradient; panics for empty, unordered or nonfinite keys/colors.

use ponko::*;
let g = ParticleGradient::new(vec![(0.0, Color::WHITE)]);
assert_eq!(g.sample(1.0), Color::WHITE);

Examples found in repository

examples/particles.rs (lines 20-23)

fn setup(ctx: &mut Ctx) {
    ctx.camera3d.position = vec3(0.0, 2.0, 7.0);
    ctx.camera3d.look_at(vec3(0.0, 1.0, 0.0));
    ctx.sky.atmosphere = false;
    let emitter = ParticleEmitter3D::new(ParticleSettings3D {
        rate: 120.0,
        burst: 40,
        lifetime: (0.7, 1.4),
        speed: (2.0, 4.0),
        shape: ParticleShape3D::Cone { angle: 0.45 },
        gravity: vec3(0.0, -3.0, 0.0),
        drag: 0.2,
        size: (0.05, 0.13),
        rotation: (0.0, std::f32::consts::TAU),
        size_over_life: ParticleCurve::new(vec![(0.0, 0.5), (0.2, 1.0), (1.0, 0.0)]),
        color_over_life: ParticleGradient::new(vec![
            (0.0, Color::rgba(1.0, 0.7, 0.2, 1.0)),
            (1.0, Color::rgba(1.0, 0.1, 0.0, 0.0)),
        ]),
        blend: ParticleBlend3D::Additive,
        max_particles: 512,
        seed: 42,
        ..Default::default()
    });
    ctx.world.spawn((Transform3D::default(), emitter));
}

examples/ribbons.rs (lines 26-29)

fn setup(ctx: &mut Ctx) {
    ctx.camera3d.position = vec3(0.0, 4.0, 9.0);
    ctx.camera3d.look_at(vec3(0.0, 0.5, 0.0));
    let floor_material = ctx.create_material(MaterialDesc::color(Color::hex(0x6B7B58)));
    let floor_data = MeshData::plane(12.0);
    let floor = ctx.create_mesh(&floor_data, floor_material);
    ctx.world.spawn((Transform3D::default(), Model::new(floor)));

    // ANCHOR: trail
    // A glowing tracer behind a flying ball: a quarter second long, thin at
    // the end and fading out.
    let mut tracer = Trail3D::new(0.25, 0.12);
    tracer.color = ParticleGradient::new(vec![
        (0.0, Color::rgb(1.0, 0.8, 0.3)),
        (1.0, Color::rgba(1.0, 0.3, 0.0, 0.0)),
    ]);
    tracer.blend = ParticleBlend3D::Additive;
    let white = ctx.default_material();
    let ball = ctx.create_mesh(&MeshData::sphere(0.15, 16), white);
    ctx.world
        .spawn((Transform3D::default(), Model::new(ball), tracer, Orbiting));
    // After a teleport: ctx.world.get_mut::<Trail3D>(entity).unwrap().clear();
    // ANCHOR_END: trail

    // ANCHOR: line
    // A laser beam 5 m long, from the entity forward.
    let beam = Line3D {
        blend: ParticleBlend3D::Additive,
        ..Line3D::new(vec![Vec3::ZERO, vec3(0.0, 0.0, -5.0)], 0.03, Color::RED)
    };
    ctx.world.spawn((Transform3D::at(vec3(-4.0, 1.5, 3.0)), beam));
    // ANCHOR_END: line

    // ANCHOR: decal
    // A 1 m scorch mark on the floor at (1, 0, -1): the box is 1 x 1 m wide
    // and 0.4 m deep, its +Z turned up, so the image is projected down.
    let up = Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2);
    let projector = Mat4::from_scale_rotation_translation(vec3(1.0, 1.0, 0.4), up, vec3(1.0, 0.0, -1.0));
    let mark = floor_data.decal(projector, 0.003);
    if !mark.indices.is_empty() {
        let scorch = ctx.create_material(MaterialDesc {
            blend: Blend::Transparent,
            ..MaterialDesc::color(Color::rgba(0.05, 0.04, 0.03, 0.8))
        });
        let mark = ctx.create_mesh(&mark, scorch);
        // Drawn where the floor is.
        ctx.world.spawn((Transform3D::default(), Model::new(mark)));
    }
    // A mesh from a glTF file works the same: ctx.load_mesh_data("models/wall.glb")?.decal(..)
    // ANCHOR_END: decal
}

pub fn sample(&self, t: f32) -> Color

Evaluates RGBA at normalized age, clamping beyond the keys.

use ponko::*;
assert_eq!(ParticleGradient::default().sample(0.0), Color::WHITE);

Trait Implementations

impl Clone for ParticleGradient

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParticleGradient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ParticleGradient

fn default() -> Self

Returns the “default value” for a type.