1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! The example from our Getting Started page.

use std::f32::consts::TAU;

use itertools::Itertools as _;

use rerun::{
    demo_util::{bounce_lerp, color_spiral},
    external::glam,
};

const NUM_POINTS: usize = 100;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rec = rerun::RecordingStreamBuilder::new("rerun_example_dna_abacus").spawn()?;

    let (points1, colors1) = color_spiral(NUM_POINTS, 2.0, 0.02, 0.0, 0.1);
    let (points2, colors2) = color_spiral(NUM_POINTS, 2.0, 0.02, TAU * 0.5, 0.1);

    rec.set_time_seconds("stable_time", 0f64);

    rec.log_static(
        "dna/structure/left",
        &rerun::Points3D::new(points1.iter().copied())
            .with_colors(colors1)
            .with_radii([0.08]),
    )?;
    rec.log_static(
        "dna/structure/right",
        &rerun::Points3D::new(points2.iter().copied())
            .with_colors(colors2)
            .with_radii([0.08]),
    )?;

    let points_interleaved: Vec<[glam::Vec3; 2]> = points1
        .into_iter()
        .interleave(points2)
        .chunks(2)
        .into_iter()
        .map(|chunk| chunk.into_iter().collect_vec().try_into().unwrap())
        .collect_vec();

    rec.log_static(
        "dna/structure/scaffolding",
        &rerun::LineStrips3D::new(points_interleaved.iter().cloned())
            .with_colors([rerun::Color::from([128, 128, 128, 255])]),
    )?;

    use rand::Rng as _;
    let mut rng = rand::thread_rng();
    let offsets = (0..NUM_POINTS).map(|_| rng.gen::<f32>()).collect_vec();

    for i in 0..400 {
        let time = i as f32 * 0.01;

        rec.set_time_seconds("stable_time", time as f64);

        let times = offsets.iter().map(|offset| time + offset).collect_vec();
        let (beads, colors): (Vec<_>, Vec<_>) = points_interleaved
            .iter()
            .enumerate()
            .map(|(n, &[p1, p2])| {
                let c = bounce_lerp(80.0, 230.0, times[n] * 2.0) as u8;
                (
                    rerun::Position3D::from(bounce_lerp(p1, p2, times[n])),
                    rerun::Color::from_rgb(c, c, c),
                )
            })
            .unzip();

        rec.log(
            "dna/structure/scaffolding/beads",
            &rerun::Points3D::new(beads)
                .with_colors(colors)
                .with_radii([0.06]),
        )?;

        rec.log(
            "dna/structure",
            &rerun::archetypes::Transform3D::from_rotation(rerun::RotationAxisAngle::new(
                glam::Vec3::Z,
                rerun::Angle::from_radians(time / 4.0 * TAU),
            )),
        )?;
    }

    Ok(())
}