krabmaga 0.6.0

A modern developing art for reliable and efficient Agent-based Model (ABM) simulation with the Rust language.
Documentation 
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

use std::f32::consts::PI;
use std::fmt::Display;
use std::hash::Hash;

use crate::bevy::prelude::{Res, Vec2};

use crate::visualization::wrappers::{ActiveState, SimulationRenderEntity};

use crate::engine::{
    fields::network::{Edge, Network},
    location::Real2D,
    state::State,
};

pub use bevy::prelude::Color;
use bevy::prelude::{Commands, Component, Query, Transform};
use bevy_prototype_lyon::draw::Stroke;
use bevy_prototype_lyon::entity::Shape;
use bevy_prototype_lyon::prelude::tess::path::path::Builder;
use bevy_prototype_lyon::prelude::{Geometry, ShapeBuilder, ShapeBuilderBase};
use bevy_prototype_lyon::shapes::Line;

pub extern crate bevy_prototype_lyon;

// Allows customization of the arrow geometry used to render edges.
pub struct ArrowOptions {
    pub length: f32,
    pub angle: f32,
}

impl Default for ArrowOptions {
    fn default() -> Self {
        ArrowOptions {
            length: 10.,
            angle: PI / 12.,
        }
    }
}

// Specifies the type of geometry to use to represent the edge, along with drawing directives if needed.
pub enum LineType {
    Line,
    // An arrow will be drawn with the arrow head placed on the second point. You can specify the length
    // of the vectors representing the arrow head segments, and the angle in radians.
    Arrow(ArrowOptions),
}

// All the data we need to properly visualize an edge.
#[derive(Component)]
pub struct EdgeRenderInfo {
    pub line_color: Color,
    pub line_width: f32,
    pub source_loc: Real2D,
    pub target_loc: Real2D,
    pub is_static: bool, // If true, render() won't loop on this edge
}

#[derive(Component)]
pub struct EdgeRender(u32, u32, Real2D, Real2D);

/// Allows rendering the edges of a graph as customizable lines through the Bevy Canvas plugin.
pub trait NetworkRender<O: Hash + Eq + Clone + Display, L: Clone + Hash + Display, S: State> {
    // Specify how to fetch a reference to the network from the state.
    fn get_network(state: &S) -> &Network<O, L>;

    // Called for each edge to let the user specify how it should be rendered
    fn get_edge_info(edge: &Edge<L>, network: &Network<O, L>) -> EdgeRenderInfo;

    fn get_loc(network: &Network<O, L>, node: u32) -> Real2D;

    fn init_network_graphics(state: &S, commands: &mut Commands) {
        let network = Self::get_network(&*state);
        for node_edges in network.edges.values() {
            for edge in node_edges {
                let EdgeRenderInfo {
                    source_loc,
                    target_loc,
                    line_color,
                    line_width,
                    is_static,
                } = Self::get_edge_info(edge, network);

                let shape = ShapeBuilder::with(&Line(
                    Vec2::new(source_loc.x, source_loc.y),
                    Vec2::new(target_loc.x, target_loc.y),
                ))
                .stroke(Stroke::new(line_color, line_width))
                .build();

                let mut spawn_command = commands.spawn((shape, Transform::default()));
                spawn_command.insert(SimulationRenderEntity);
                if !is_static {
                    spawn_command.insert(EdgeRender(edge.u, edge.v, source_loc, target_loc));
                }
            }
        }
    }

    // If the nodes connected by the edge have moved, we regenerate the path mesh related to the edge.
    fn render(state_wrapper: Res<ActiveState<S>>, mut query: Query<(&mut Shape, &mut EdgeRender)>) {
        let state = state_wrapper.0.lock().expect("error on lock");
        let network = Self::get_network(&*state);
        for (mut shape, mut edge_render) in query.iter_mut() {
            let source_loc = Self::get_loc(network, edge_render.0);
            let target_loc = Self::get_loc(network, edge_render.1);
            if source_loc != edge_render.2 || target_loc != edge_render.3 {
                let mut builder = Builder::new();
                Line(
                    Vec2::new(source_loc.x, source_loc.y),
                    Vec2::new(target_loc.x, target_loc.y),
                )
                .add_geometry(&mut builder);
                shape.path = builder.build();
                edge_render.2 = source_loc;
                edge_render.3 = target_loc;
            }
        }
    }
}