bevy_react_core 0.7.0

The core bridge of bevy-react (drive bevy_ui from React over an embedded V8 runtime). Apps depend on the `bevy-react` crate.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Stage 5 — the `Ext` publish: feature-owned bindings evaluate into the
//! entity's `DrivenExtValues`, the binding picking scalar or color.
use bevy::prelude::*;
use bevy::ui::UiTransform;

use super::super::protocol::{AnimatableProperty, AnimatedBindings, Binding};
use super::super::{AnimatedNode, SharedValues};
use super::apply_animated_nodes;
use crate::ext::{DrivenExtValues, DrivenValue};

fn ext(name: &str) -> AnimatableProperty {
    AnimatableProperty::Ext {
        domain: "probe",
        name: name.into(),
    }
}

/// A probe entity carrying a scalar (`size`), an interpolated scalar
/// (`y`), and a color (`color`) binding, over shared values 1 and 2.
fn probe_world() -> (World, Entity) {
    let mut world = World::new();
    world.init_resource::<crate::layer::LayerContentDirt>();
    let mut values = SharedValues::default();
    values.set(1, 2.5);
    values.set(2, 0.5);
    world.insert_resource(values);

    let bindings = AnimatedBindings(
        [
            (ext("size"), Binding::Shared { id: 1 }),
            (
                ext("y"),
                Binding::Interpolate {
                    id: 2,
                    input: vec![0.0, 1.0],
                    output: vec![0.0, 10.0],
                },
            ),
            (
                ext("color"),
                Binding::InterpolateColor {
                    id: 2,
                    input: vec![0.0, 1.0],
                    output: vec![[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]],
                },
            ),
        ]
        .into_iter()
        .collect(),
    );
    let e = world
        .spawn((
            AnimatedNode(bindings),
            UiTransform::default(),
            DrivenExtValues::default(),
        ))
        .id();
    (world, e)
}

fn apply(world: &mut World) {
    let mut schedule = Schedule::default();
    schedule.add_systems(apply_animated_nodes);
    schedule.run(world);
}

/// Scalars publish as `Scalar`, `interpolateColor` as an sRGB `Color`; the
/// typed getters only answer for their own kind.
#[test]
fn ext_bindings_publish_scalars_and_colors() {
    let (mut world, e) = probe_world();
    apply(&mut world);

    let driven = world.entity(e).get::<DrivenExtValues>().unwrap();
    assert_eq!(driven.get("probe", "size"), Some(2.5));
    assert_eq!(driven.get("probe", "y"), Some(5.0));
    assert_eq!(
        driven.value("probe", "color"),
        Some(DrivenValue::Color([0.5, 0.0, 0.5, 1.0]))
    );
    assert_eq!(
        driven.get_color("probe", "color"),
        Some(Srgba::new(0.5, 0.0, 0.5, 1.0))
    );
    assert_eq!(
        driven.get("probe", "color"),
        None,
        "a color is not a scalar"
    );
    assert_eq!(
        driven.get_color("probe", "size"),
        None,
        "a scalar is not a color"
    );
}

/// A binding whose shared value is missing publishes nothing, for either
/// kind — the consumer sees the gap.
#[test]
fn ext_binding_without_shared_value_publishes_nothing() {
    let (mut world, e) = probe_world();
    world.insert_resource(SharedValues::default());
    apply(&mut world);

    let driven = world.entity(e).get::<DrivenExtValues>().unwrap();
    assert!(driven.0.is_empty(), "nothing evaluable: {driven:?}");
}

/// A settled frame (same shared values) never ticks the publish slot.
#[test]
fn settled_ext_publish_does_not_tick() {
    let (mut world, e) = probe_world();
    apply(&mut world);
    let before = world
        .entity(e)
        .get_ref::<DrivenExtValues>()
        .unwrap()
        .last_changed();
    world.increment_change_tick();
    apply(&mut world);
    let after = world
        .entity(e)
        .get_ref::<DrivenExtValues>()
        .unwrap()
        .last_changed();
    assert_eq!(before, after, "a settled publish must not re-write");
}