Struct charred_path::piecewise_linear::PuncturePoint

pub struct PuncturePoint { /* private fields */ }

PuncturePoint represents a hole in the plane from the perspective of homotopy.

A PuncturePoint is a point in the plane that acts as a puncture or hole, affecting the homotopy type of paths traveling around it.

Each PuncturePoint contains a position which is a Vec2 representing the position of the point, and a name which is a char that uniquely identifies the puncture point. It is used to represent the traversal around the puncture point when writing the homotopy type of a path. name.to_ascii_lowercase() is used to represent clockwise traversal around the puncture point, and name.to_ascii_uppercase() is used to represent counterclockwise traversal.

Note that the name character is made uppercase upon instantiation.

Examples

use bevy::prelude::*;
use charred_path::piecewise_linear::PuncturePoint;

let position = Vec2::new(1.0, 2.0);
let puncture_point = PuncturePoint::new(position, 'a');
assert_eq!(puncture_point.position(), &position);
assert_eq!(puncture_point.name(), 'A');

Implementations

impl PuncturePoint

pub const fn new(position: Vec2, name: char) -> Self

Represents a puncture point in the plane.

Examples found in repository

examples/homotopy_word_debug.rs (line 33)

fn init(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    // spawn the camera
    commands.spawn(Camera2dBundle::default());

    // Define some puncture points
    let puncture_points = vec![
        PuncturePoint::new(Vec2::new(-225.0, 100.0), 'A'),
        PuncturePoint::new(Vec2::new(-75.0, 150.0), 'B'),
        PuncturePoint::new(Vec2::new(75.0, 150.0), 'C'),
        PuncturePoint::new(Vec2::new(225.0, 100.0), 'D'),
    ];

    // Render puncture points as red circles
    let radius = 5.0;
    let material = materials.add(ColorMaterial::from(Color::RED));
    for point in puncture_points.iter() {
        commands.spawn(MaterialMesh2dBundle {
            mesh: meshes.add(Circle::new(radius)).into(),
            material: material.clone(),
            transform: Transform::from_translation(point.position().extend(0.0)),
            ..Default::default()
        });
    }

    // spawn the player
    commands.spawn((
        Player,
        MaterialMesh2dBundle {
            mesh: meshes.add(Circle::new(10.0)).into(),
            material: materials.add(PLAYER_COLOR),
            transform: Transform::from_translation(PLAYER_START),
            ..Default::default()
        },
        PathType::new(PLAYER_START.truncate(), puncture_points),
    ));

    // spawn the text
    commands.spawn((
        TextBundle::from_section(
            "default",
            TextStyle {
                font_size: 60.0,
                ..Default::default()
            },
        )
        .with_text_justify(JustifyText::Center)
        .with_style(Style {
            position_type: PositionType::Absolute,
            bottom: Val::Px(5.0),
            right: Val::Px(5.0),
            ..Default::default()
        }),
        HomotopyWordText,
    ));
}

pub const fn position(&self) -> &Vec2

Returns the position of the puncture point in 2D.

Examples found in repository

examples/homotopy_word_debug.rs (line 46)

fn init(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    // spawn the camera
    commands.spawn(Camera2dBundle::default());

    // Define some puncture points
    let puncture_points = vec![
        PuncturePoint::new(Vec2::new(-225.0, 100.0), 'A'),
        PuncturePoint::new(Vec2::new(-75.0, 150.0), 'B'),
        PuncturePoint::new(Vec2::new(75.0, 150.0), 'C'),
        PuncturePoint::new(Vec2::new(225.0, 100.0), 'D'),
    ];

    // Render puncture points as red circles
    let radius = 5.0;
    let material = materials.add(ColorMaterial::from(Color::RED));
    for point in puncture_points.iter() {
        commands.spawn(MaterialMesh2dBundle {
            mesh: meshes.add(Circle::new(radius)).into(),
            material: material.clone(),
            transform: Transform::from_translation(point.position().extend(0.0)),
            ..Default::default()
        });
    }

    // spawn the player
    commands.spawn((
        Player,
        MaterialMesh2dBundle {
            mesh: meshes.add(Circle::new(10.0)).into(),
            material: materials.add(PLAYER_COLOR),
            transform: Transform::from_translation(PLAYER_START),
            ..Default::default()
        },
        PathType::new(PLAYER_START.truncate(), puncture_points),
    ));

    // spawn the text
    commands.spawn((
        TextBundle::from_section(
            "default",
            TextStyle {
                font_size: 60.0,
                ..Default::default()
            },
        )
        .with_text_justify(JustifyText::Center)
        .with_style(Style {
            position_type: PositionType::Absolute,
            bottom: Val::Px(5.0),
            right: Val::Px(5.0),
            ..Default::default()
        }),
        HomotopyWordText,
    ));
}

pub const fn name(&self) -> char

Returns the label associated to the puncture point.

Trait Implementations

impl Clone for PuncturePoint

fn clone(&self) -> PuncturePoint

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for PuncturePoint

where Self: Send + Sync + 'static,

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either TableStorage or SparseStorage.

impl Debug for PuncturePoint

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

Formats the value using the given formatter.

impl PartialEq for PuncturePoint

fn eq(&self, other: &PuncturePoint) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for PuncturePoint

impl StructuralPartialEq for PuncturePoint