Struct fdg_sim::Simulation

pub struct Simulation<N, E, Ty = Undirected> { /* private fields */ }

A simulation for managing the main event loop and forces.

Implementations

impl<N, E, Ty: EdgeType> Simulation<N, E, Ty>

pub fn from_graph(
    graph: ForceGraph<N, E, Ty>,
    parameters: SimulationParameters<N, E, Ty>
) -> Self

Create a simulation from a ForceGraph.

Examples found in repository

examples/basic.rs (line 14)

fn main() {
    // initialize a graph
    let mut graph: ForceGraph<(), ()> = ForceGraph::default();

    // add nodes to it
    let one = graph.add_force_node("one", ());
    let two = graph.add_force_node("two", ());
    let _three = graph.add_force_node("three", ());
    graph.add_edge(one, two, ());

    // create a simulation from the graph
    let mut simulation = Simulation::from_graph(graph, SimulationParameters::default());

    // your event/render loop
    for frame in 0..50 {
        // update the nodes positions based on force algorithm
        simulation.update(0.035);

        // render (print) your nodes new locations.
        println!("---- frame {frame} ----");
        for node in simulation.get_graph().node_weights() {
            println!("\"{}\" - {:?}", node.name, node.location);
        }
    }
}

src/simulation.rs (line 201)

    fn default() -> Self {
        Self::from_graph(ForceGraph::default(), SimulationParameters::default())
    }

pub fn reset_node_placement(&mut self)

Randomly place the nodes within the starting square. In practice, this restarts the simulation.

Examples found in repository

src/simulation.rs (line 100)

    pub fn from_graph(
        graph: ForceGraph<N, E, Ty>,
        parameters: SimulationParameters<N, E, Ty>,
    ) -> Self {
        let mut myself = Self { graph, parameters };

        myself.reset_node_placement();

        myself
    }

pub fn update(&mut self, dt: f32)

Update the graph’s node’s positions for a given interval.

Examples found in repository

examples/basic.rs (line 19)

fn main() {
    // initialize a graph
    let mut graph: ForceGraph<(), ()> = ForceGraph::default();

    // add nodes to it
    let one = graph.add_force_node("one", ());
    let two = graph.add_force_node("two", ());
    let _three = graph.add_force_node("three", ());
    graph.add_edge(one, two, ());

    // create a simulation from the graph
    let mut simulation = Simulation::from_graph(graph, SimulationParameters::default());

    // your event/render loop
    for frame in 0..50 {
        // update the nodes positions based on force algorithm
        simulation.update(0.035);

        // render (print) your nodes new locations.
        println!("---- frame {frame} ----");
        for node in simulation.get_graph().node_weights() {
            println!("\"{}\" - {:?}", node.name, node.location);
        }
    }
}

pub fn update_custom(&mut self, force: &Force<N, E, Ty>, dt: f32)

Update the graph’s node’s positions for a given interval with a custom Force.

pub fn visit_nodes(&self, cb: &mut impl Fn(&Node<N>))

Run a callback on all the nodes.

pub fn visit_edges(&self, cb: &mut impl Fn(&Node<N>, &Node<N>))

Run a callback on all of the edges.

pub fn get_graph(&self) -> &ForceGraph<N, E, Ty>

Retrieve a reference to the internal ForceGraph.

Examples found in repository

examples/basic.rs (line 23)

fn main() {
    // initialize a graph
    let mut graph: ForceGraph<(), ()> = ForceGraph::default();

    // add nodes to it
    let one = graph.add_force_node("one", ());
    let two = graph.add_force_node("two", ());
    let _three = graph.add_force_node("three", ());
    graph.add_edge(one, two, ());

    // create a simulation from the graph
    let mut simulation = Simulation::from_graph(graph, SimulationParameters::default());

    // your event/render loop
    for frame in 0..50 {
        // update the nodes positions based on force algorithm
        simulation.update(0.035);

        // render (print) your nodes new locations.
        println!("---- frame {frame} ----");
        for node in simulation.get_graph().node_weights() {
            println!("\"{}\" - {:?}", node.name, node.location);
        }
    }
}

pub fn get_graph_mut(&mut self) -> &mut ForceGraph<N, E, Ty>

Retrieve a mutable reference to the internal ForceGraph.

pub fn set_graph(&mut self, graph: ForceGraph<N, E, Ty>)

Set the internal ForceGraph.

pub fn parameters(&self) -> &SimulationParameters<N, E, Ty>

Retrieve a reference to the internal SimulationParameters.

pub fn parameters_mut(&mut self) -> &mut SimulationParameters<N, E, Ty>

Retreive a mutable reference to the internal SimulationParameters.

pub fn find(&self, query: Vec3, radius: f32) -> Option<NodeIndex>

Retreive a node from the graph based on a query.

Trait Implementations

impl<N: Clone, E: Clone, Ty: Clone> Clone for Simulation<N, E, Ty>

fn clone(&self) -> Simulation<N, E, Ty>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N, E, Ty: EdgeType> Default for Simulation<N, E, Ty>

fn default() -> Self

Returns the “default value” for a type.