Struct Transform 

pub struct Transform {
    pub position: Position,
    pub rotation: f32,
    pub scale: Vector2<f32>,
    /* private fields */
}

Struct to represent the transform matrix of every object rendered.

Fields

position: Position

rotation: f32

scale: Vector2<f32>

Implementations

impl Transform

pub fn new(position: Position, rotation: f32, scale: Vector2<f32>) -> Self

Create a new transform with parameters.

Examples found in repository

examples/gravity_simulation.rs (lines 20-24)

fn setup(context: &mut Context) {
    let table: Shape = Shape::new(Orientation::Horizontal, GeometryType::Rectangle, Color::BLACK);
    let object: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(Circle::default()), Color::BLUE);

    context.commands.spawn(vec![
        Box::new(table),
        Box::new(Transform::new(
            Position::new(Vector2::new(0.0, -0.70), Strategy::Normalized),
            0.0,
            Vector2::new(0.90, 0.10)
        )),
        Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
    ]);

    context.commands.spawn(vec![
        Box::new(object),
        Box::new(Transform::new(
            Position::new(Vector2::new(400.0, 100.0), Strategy::Pixelated),
            0.0,
            Vector2::new(0.50, 0.50)
        )),
        Box::new(Collision::new(Collider::new_simple(GeometryType::Square))),
        Box::new(Gravity::new(0.0)),
        Box::new(Velocity::new(Vector2::new(0.2, 0.2))),
        Box::new(RigidBody::new(BodyType::Dynamic, 1.0, 0.9, 1.0))
    ]);
}

examples/simple_camera.rs (lines 27-31)

fn setup(context: &mut Context) {
    let player: Sprite = Sprite::new("textures/lotus_pink_256x256.png".to_string());
    let secondary_sprite: Sprite = Sprite::new("textures/lotus_pink_256x256.png".to_string());
    let shape: Shape = Shape::new(Orientation::Horizontal, GeometryType::Square, Color::BURGUNDY);
    let text: Text = Text::new(
        &mut context.render_state,
        Font::new(Fonts::RobotoMono.get_path(), 30.0),
        Position::new(Vector2::new(0.0, 0.0), Strategy::Pixelated),
        Color::BLACK,
        "Boiler Plate".to_string()
    );

    context.commands.spawn(
        vec![
            Box::new(player),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.25, 0.25)
            )),
            Box::new(Velocity::new(Vector2::new(1.0, 1.0)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(secondary_sprite),
            Box::new(Transform::new(
                Position::new(Vector2::new(-0.25, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.25, 0.25)
            ))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(shape),
            Box::new(Transform::new(
                Position::new(Vector2::new(-0.75, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.25, 0.25)
            )),
            Box::new(Velocity::new(Vector2::new(1.0, 1.0)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(text)
        ]
    );
}

examples/physics_simulation.rs (lines 29-33)

fn setup(context: &mut Context) {
    let circle: Circle = Circle::new(64, 0.5);
    let red_object: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(circle.clone()), Color::RED);
    let blue_object: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(circle.clone()), Color::BLUE);

    context.commands.spawn(
        vec![
            Box::new(red_object),
            Box::new(Object()),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.30, 0.30)
            )),
            Box::new(Velocity::new(Vector2::new(0.45, 0.45))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(blue_object),
            Box::new(Object()),
            Box::new(Transform::new(
                Position::new(Vector2::new(-0.45, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.30, 0.30)
            )),
            Box::new(Velocity::new(Vector2::new(0.45, 0.45))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, -1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, 1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Vertical, Vector2::new(1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
    spawn_border(context, Orientation::Vertical, Vector2::new(-1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
}

fn update(context: &mut Context) {
    let mut query: Query = Query::new(&context.world).with::<Object>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();

    check_border_collision(context, &entities);
    check_object_collision(context, &entities);
    move_objects(context, &entities);
}

fn spawn_border(context: &mut Context, orientation: Orientation, position: Vector2<f32>, scale: Vector2<f32>) {
    let border: Shape = Shape::new(orientation, GeometryType::Rectangle, Color::WHITE);

    context.commands.spawn(
        vec![
            Box::new(border),
            Box::new(Border()),
            Box::new(Transform::new(
                Position::new(position, Strategy::Normalized),
                0.0,
                scale
            )),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );
}

examples/simple_shapes.rs (lines 37-41)

fn setup(context: &mut Context) {
    context.game_loop_listener.fps_cap(120);

    let my_square: Shape = Shape::new(Orientation::Horizontal, GeometryType::Square, Color::BLUE);
    let my_rectangle: Shape = Shape::new(Orientation::Horizontal, GeometryType::Rectangle, Color::GREEN);
    let my_triangle: Shape = Shape::new(Orientation::Horizontal, GeometryType::Triangle, Color::RED);
    let my_circle: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(Circle::new(64, 0.5)), Color::BLACK);

    context.commands.spawn(
        vec![
            Box::new(my_square),
            Box::new(Transform::new(
                Position::new(Vector2::new(-0.60, -0.25), Strategy::Normalized),
                0.0,
                Vector2::new(0.10, 0.10)
            )),
            Box::new(MySquare())
        ]
    );
    context.commands.spawn(
        vec![
            Box::new(my_rectangle),
            Box::new(Transform::new(
                Position::new(Vector2::new(-0.35, 0.20), Strategy::Normalized),
                0.0,
                Vector2::new(0.50, 0.50)
            )),
            Box::new(MyRectangle())
        ]
    );
    context.commands.spawn(
        vec![
            Box::new(my_triangle),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.50, 0.50), Strategy::Normalized),
                0.0,
                Vector2::new(0.25, 0.25)
            )),
            Box::new(MyTriangle())
        ]
    );
    context.commands.spawn(
        vec![
            Box::new(my_circle),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.80, 0.50), Strategy::Normalized),
                0.0,
                Vector2::new(0.25, 0.25)
            )),
            Box::new(MyCircle())
        ]
    );
}

examples/performance.rs (lines 37-41)

fn setup(context: &mut Context) {
    let circle: Circle = Circle::new(64, 0.5);
    let mut thread_rng: ThreadRng = rng();

    let left_border_perimeter: f64 = -1.3;
    let right_border_perimiter: f64 = 1.3;
    let bottom_border_perimeter: f64 = -0.9;
    let top_border_perimeter: f64 = 0.9;

    // Update the number of spawns for performance benchmarking.
    for _ in 1..=10 {
        let randomic_position_x: f32 = thread_rng.random_range(left_border_perimeter..right_border_perimiter) as f32;
        let randomic_position_y: f32 = thread_rng.random_range(bottom_border_perimeter..top_border_perimeter) as f32;

        let randomic_velocity_x: f32 = thread_rng.random_range(-0.5..0.5) as f32;
        let randomic_velocity_y: f32 = thread_rng.random_range(-0.5..0.5) as f32;

        context.commands.spawn(
            vec![
                Box::new(Shape::new(Orientation::Horizontal, GeometryType::Circle(circle.clone()), Color::BLUE)),
                Box::new(Object()),
                Box::new(Transform::new(
                    Position::new(Vector2::new(randomic_position_x, randomic_position_y), Strategy::Normalized),
                    0.0,
                    Vector2::new(0.15, 0.15)
                )),
                Box::new(Velocity::new(Vector2::new(randomic_velocity_x, randomic_velocity_y))),
                Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
            ]
        );
    }

    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, -1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, 1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Vertical, Vector2::new(1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
    spawn_border(context, Orientation::Vertical, Vector2::new(-1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
}

fn update(context: &mut Context) {
    context.commands.show_fps(context.game_loop_listener.current_fps, Color::BLACK);

    let mut query: Query = Query::new(&context.world).with::<Object>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();

    check_border_collision(context, &entities);
    move_objects(context, &entities);
}

fn spawn_border(context: &mut Context, orientation: Orientation, position: Vector2<f32>, scale: Vector2<f32>) {
    let border: Shape = Shape::new(orientation, GeometryType::Rectangle, Color::WHITE);

    context.commands.spawn(
        vec![
            Box::new(border),
            Box::new(Border()),
            Box::new(Transform::new(
                Position::new(position, Strategy::Normalized),
                0.0,
                scale
            )),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );
}

examples/breakout.rs (lines 97-101)

fn setup(context: &mut Context) {
    let player: Shape = Shape::new(Orientation::Horizontal, GeometryType::Rectangle, Color::PURPLE);
    let little_ball: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(Circle::new(64, 0.2)), Color::BLACK);
    let start_text: Text = Text::new(
        &mut context.render_state,
        Font::new(Fonts::RobotoMonoItalic.get_path(), 40.0),
        Position::new(Vector2::new(298.0, 380.0), Strategy::Pixelated),
        Color::BLACK,
        "> enter <".to_string()
    );

    let mut thread_rng: ThreadRng = rand::rng();
    let random_direction: bool = thread_rng.random_bool(1.0 / 3.0);
 
    let velocity_x: f32 = if random_direction {
        1.2
    } else {
        -1.2
    };

    context.commands.add_resources(vec![
        Box::new(LittleBallRespawnTimer::new()),
        Box::new(NextState::default())
    ]);
    context.commands.spawn(vec![Box::new(start_text)]);

    context.commands.spawn(
        vec![
            Box::new(player),
            Box::new(Player()),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, -0.85), Strategy::Normalized),
                0.0,
                Vector2::new(0.15, 0.10)
            )),
            Box::new(Velocity::new(Vector2::new(2.0, 2.0))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(little_ball),
            Box::new(LittleBall()),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, -0.5), Strategy::Normalized),
                0.0,
                Vector2::new(0.10, 0.10)
            )),
            Box::new(Velocity::new(Vector2::new(velocity_x, -0.5))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    spawn_border(context, Vector2::new(1.05, 0.0));
    spawn_border(context, Vector2::new(-1.05, 0.0));
    spawn_targets(context);
}

fn update(context: &mut Context) {
    let input: Input = {
        let input_ref: ResourceRefMut<'_, Input> = context.world.get_resource_mut::<Input>().unwrap();
        input_ref.clone()
    };
    let is_hover: bool = input.mouse_position.x >= 298.0 && (input.mouse_position.y > 380.0 && input.mouse_position.y < 416.0);

    if
        input.is_key_released(KeyCode::Enter) ||
        (input.is_mouse_button_released(MouseButton::Left) && is_hover)
    {
        let mut next_state: ResourceRefMut<'_, NextState> = context.world.get_resource_mut::<NextState>().unwrap();
        next_state.0 = GameState::Running;

        let mut query: Query = Query::new(&context.world).with::<Text>();
        if let Some(entity) = query.entities_with_components().unwrap().first() {
            context.commands.despawn(entity.clone());
        }
    }

    if context.world.get_resource::<NextState>().unwrap().0 == GameState::Running {
        let mut player_query: Query = Query::new(&context.world).with::<Player>();
        let player_entity: Entity = player_query.entities_with_components().unwrap().first().unwrap().clone();

        let mut little_ball_query: Query = Query::new(&context.world).with::<LittleBall>();
        let little_ball_entity: Entity = little_ball_query.entities_with_components().unwrap().first().unwrap().clone();

        let mut thread_rng: ThreadRng = rand::rng();
        let random_factor: f32 = thread_rng.random_range(-0.5..0.5);

        move_player(context, input, player_entity);
        move_little_ball(context, little_ball_entity);
        check_player_little_ball_collision(context, player_entity, little_ball_entity, random_factor);
        check_little_ball_borders_collision(context, little_ball_entity, random_factor);
        check_litte_ball_targets_collision(context, little_ball_entity, random_factor);
        respawn_little_ball_after_outbounds(context, little_ball_entity);
    }
}

fn spawn_border(context: &mut Context, position: Vector2<f32>) {
    let border: Shape = Shape::new(Orientation::Vertical, GeometryType::Rectangle, Color::CYAN);

    context.commands.spawn(
        vec![
            Box::new(border),
            Box::new(Border()),
            Box::new(Transform::new(
                Position::new(position, Strategy::Normalized),
                0.0,
                Vector2::new(0.01, context.window_configuration.height as f32)
            )),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );
}

fn spawn_targets(context: &mut Context) {
    let width: f32 = 0.15;
    let height: f32 = 0.10;

    let rows: i32 = 8;
    let columns: i32 = 10;
    let spacing_x: f32 = 0.09;
    let spacing_y: f32 = 0.02;

    let start_x: f32 = -(columns as f32 * (width + spacing_x)) / 2.0;
    let start_y: f32 = 1.0 - 0.1;

    for row in 0..rows {
        for column in 0..columns {
            let x: f32 = start_x + column as f32 * (width + spacing_x);
            let y: f32 = start_y - row as f32 * (height + spacing_y);

            let mut color: Color = Color::RED;

            if row == 2 || row == 3 {
                color = Color::ORANGE;
            } else if row == 4 || row == 5 {
                color = Color::GREEN;
            } else if row == 6 || row == 7 {
                color = Color::YELLOW;
            }

            context.commands.spawn(
                vec![
                    Box::new(Shape::new(Orientation::Horizontal, GeometryType::Rectangle, color)), 
                    Box::new(Target()),
                    Box::new(Transform::new(
                        Position::new(Vector2::new(x, y), Strategy::Normalized),
                        0.0,
                        Vector2::new(width, height)
                    )),
                    Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle))),
                ]
            );
        }
    }
}

Additional examples can be found in:

• examples/pong.rs

pub fn new_simple(position: Position) -> Self

Create a new transform with only the position as an argument.

Examples found in repository

examples/simple_sprite.rs (line 20)

fn setup(context: &mut Context) {
    let sprite: Sprite = Sprite::new("textures/lotus_pink_256x256.png".to_string());

    context.commands.spawn(
        vec![
            Box::new(sprite),
            Box::new(Transform::new_simple(Position::new(Vector2::new(-0.50, -0.50), Strategy::Normalized))),
            Box::new(Velocity::new(Vector2::new(0.50, 0.50)))
        ]
    );
}

pub fn to_matrix(&self) -> Matrix4<f32>

Returns the current transform struct as a matrix of f32s.

pub fn write_update_to_buffer(&self, render_state: &RenderState)

Write the transform matrix updates to its related buffer on rendering surface.

pub fn position(self, position: Position) -> Self

Set the position on initialization.

pub fn set_position( &mut self, render_state: &RenderState, position: Vector2<f32>, )

Set the current position and sends it to the buffer.

Examples found in repository

examples/performance.rs (line 112)

fn move_objects(context: &mut Context, entities: &Vec<Entity>) {
    for entity in entities {
        let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(entity).unwrap();
        let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(entity).unwrap();

        let new_position: Vector2<f32> = transform.position.to_vec() + velocity.to_vec() * context.delta;
        transform.set_position(&context.render_state, new_position);
    }
}

examples/physics_simulation.rs (line 138)

fn move_objects(context: &mut Context, entities: &Vec<Entity>) {
    for entity in entities {
        let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(entity).unwrap();
        let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(entity).unwrap();

        let new_position: Vector2<f32> = transform.position.to_vec() + velocity.to_vec() * context.delta;
        transform.set_position(&context.render_state, new_position);
    }
}

examples/breakout.rs (line 243)

fn move_little_ball(context: &mut Context, little_ball_entity: Entity) {
    let mut little_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&little_ball_entity).unwrap();
    let little_ball_velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(&little_ball_entity).unwrap();

    let new_position: Vector2<f32> = little_ball_transform.position.to_vec() + little_ball_velocity.to_vec() * context.delta;
    little_ball_transform.set_position(&context.render_state, new_position);
}

fn check_player_little_ball_collision(context: &mut Context, player_entity: Entity, little_ball_entity: Entity, random_factor: f32) {
    let mut little_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&little_ball_entity).unwrap();
    let mut little_ball_velocity: ComponentRefMut<'_, Velocity> = context.world.get_entity_component_mut::<Velocity>(&little_ball_entity).unwrap();
    let little_ball_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(&little_ball_entity).unwrap();

    let player_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(&player_entity).unwrap();

    if Collision::check(CollisionAlgorithm::Aabb, &player_collision, &little_ball_collision) {
        let velocity_magnitude: f32 = little_ball_velocity.to_vec().magnitude();
        let collision_point: f32 = (
            (little_ball_collision.collider.position.x - player_collision.collider.position.x) / 
            (player_collision.collider.scale.x * 0.5)
        ).clamp(-1.0, 1.0);
        
        let mut new_direction: Vector2<f32> = Vector2::new(
            collision_point * 1.5,
            1.0 - collision_point.abs() * 0.3
        ).normalize();

        new_direction.x += random_factor * 0.15;
        new_direction = new_direction.normalize();

        little_ball_velocity.x = new_direction.x * velocity_magnitude;
        little_ball_velocity.y = new_direction.y * velocity_magnitude;
        little_ball_transform.position.y += 0.03;
    }
}

fn check_little_ball_borders_collision(context: &mut Context, little_ball_entity: Entity, random_factor: f32) {
    let mut border_query: Query = Query::new(&context.world).with::<Border>();
    let borders_entities: Vec<Entity> = border_query.entities_with_components().unwrap();

    let mut little_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&little_ball_entity).unwrap();
    let mut little_ball_velocity: ComponentRefMut<'_, Velocity> = context.world.get_entity_component_mut::<Velocity>(&little_ball_entity).unwrap();
    let little_ball_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(&little_ball_entity).unwrap();

    for border in &borders_entities {
        let border_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(border).unwrap();

        if Collision::check(CollisionAlgorithm::Aabb, &little_ball_collision, &border_collision) {
            let velocity_magnitude: f32 = little_ball_velocity.to_vec().magnitude();
            let collision_normal: Vector2<f32> = if border_collision.collider.position.x > 0.0 {
                Vector2::new(-1.0, 0.0)
            } else {
                Vector2::new(1.0, 0.0)
            };

            let new_direction: Vector2<f32> = (
                little_ball_velocity.to_vec().normalize() - 2.0 *
                little_ball_velocity.to_vec().normalize().dot(collision_normal) * collision_normal
            ).normalize();
            
            let randomized_direction: Vector2<f32> = Vector2::new(
                new_direction.x + random_factor * 0.3,
                new_direction.y
            ).normalize();

            little_ball_velocity.x = randomized_direction.x * velocity_magnitude;
            little_ball_velocity.y = randomized_direction.y * velocity_magnitude;

            let collision_offset: Vector2<f32> = collision_normal * 0.02;
            little_ball_transform.position.x += collision_offset.x;
        }
    }
}

fn check_litte_ball_targets_collision(context: &mut Context, little_ball_entity: Entity, random_factor: f32) {
    let mut targets_query: Query = Query::new(&context.world).with::<Target>();
    let targets_entities: Vec<Entity> = targets_query.entities_with_components().unwrap();

    let mut little_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&little_ball_entity).unwrap();
    let mut little_ball_velocity: ComponentRefMut<'_, Velocity> = context.world.get_entity_component_mut::<Velocity>(&little_ball_entity).unwrap();
    let little_ball_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(&little_ball_entity).unwrap();

    for target in &targets_entities {
        let target_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(target).unwrap();

        if Collision::check(CollisionAlgorithm::Aabb, &little_ball_collision, &target_collision) {
            let velocity_magnitude: f32 = little_ball_velocity.to_vec().magnitude();
            let impact_vector: Vector2<f32> = (target_collision.collider.position - little_ball_collision.collider.position).normalize();

            let mut new_direction: Vector2<f32> = Vector2::new(
                -impact_vector.x * 0.8 + random_factor * 0.2,
                -impact_vector.y * 0.8 + random_factor * 0.2
            ).normalize();

            new_direction.y = new_direction.y.signum() * new_direction.y.abs().max(0.3);

            little_ball_velocity.x = new_direction.x * velocity_magnitude;
            little_ball_velocity.y = new_direction.y * velocity_magnitude;

            little_ball_transform.position.x -= impact_vector.x * 0.05;
            little_ball_transform.position.y -= impact_vector.y * 0.05;
            context.commands.despawn(target.clone());
        }
    }
}

fn respawn_little_ball_after_outbounds(context: &mut Context, little_ball_entity: Entity) {
    let mut litte_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&little_ball_entity).unwrap();
    let position_default: Vector2<f32> = Vector2::new(0.0, -0.25);

    if litte_ball_transform.position.y < -1.0 {
        let mut little_ball_respawn_timer: ResourceRefMut<'_, LittleBallRespawnTimer> = context.world.get_resource_mut::<LittleBallRespawnTimer>().unwrap();
        little_ball_respawn_timer.0.tick(context.delta);

        if little_ball_respawn_timer.0.is_finished() {
            litte_ball_transform.set_position(&context.render_state, position_default);
        }
    }
}

examples/pong.rs (line 186)

fn move_gray_racket(context: &mut Context, input: Input) {
    let mut query: Query = Query::new(&context.world).with::<GrayRacket>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();
    let gray_racket_entity: &Entity = entities.first().unwrap();

    let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(gray_racket_entity).unwrap();
    let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(gray_racket_entity).unwrap();

    if input.is_key_pressed(KeyCode::KeyW) {
        transform.position.y += velocity.y * context.delta;
        let new_position: Vector2<f32> = Vector2::new(transform.position.x, transform.position.y);
        transform.set_position(&context.render_state, new_position);
    } else if input.is_key_pressed(KeyCode::KeyS) {
        transform.position.y -= velocity.y * context.delta;
        let new_position: Vector2<f32> = Vector2::new(transform.position.x, transform.position.y);
        transform.set_position(&context.render_state, new_position);
    }
}

fn move_pink_racket(context: &mut Context, input: Input) {
    let mut query: Query = Query::new(&context.world).with::<PinkRacket>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();
    let pink_racket_entity: &Entity = entities.first().unwrap();

    let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(pink_racket_entity).unwrap();
    let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(pink_racket_entity).unwrap();
    
    if input.is_key_pressed(KeyCode::ArrowUp) {
        transform.position.y += velocity.y * context.delta;
        let new_position: Vector2<f32> = Vector2::new(transform.position.x, transform.position.y);
        transform.set_position(&context.render_state, new_position);
    } else if input.is_key_pressed(KeyCode::ArrowDown) {
        transform.position.y -= velocity.y * context.delta;
        let new_position: Vector2<f32> = Vector2::new(transform.position.x, transform.position.y);
        transform.set_position(&context.render_state, new_position);
    }
}

fn move_pong_ball(context: &mut Context, pong_ball: &Entity) {
    let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&pong_ball).unwrap();
    let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(&pong_ball).unwrap();

    let new_position: Vector2<f32> = transform.position.to_vec() + velocity.to_vec() * context.delta;
    transform.set_position(&context.render_state, new_position);
}

fn check_rackets_ball_collision(context: &mut Context, pong_ball: &Entity, random_factor: f32) {
    let mut racket_query: Query = Query::new(&context.world).with::<Racket>();
    let rackets: Vec<Entity> = racket_query.entities_with_components().unwrap();
    let mut game_audio: ResourceRefMut<'_, GameAudio> = context.world.get_resource_mut::<GameAudio>().unwrap();

    for racket in &rackets {
        let racket_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(racket).unwrap();
        let racket_transform: ComponentRef<'_, Transform> = context.world.get_entity_component::<Transform>(racket).unwrap();

        let pong_ball_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(&pong_ball).unwrap();
        let mut pong_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&pong_ball).unwrap();
        let mut pong_ball_velocity: ComponentRefMut<'_, Velocity> = context.world.get_entity_component_mut::<Velocity>(&pong_ball).unwrap();

        if Collision::check(CollisionAlgorithm::Aabb, &racket_collision, &pong_ball_collision) {
            game_audio.0.play_static_sound("racket_hit".to_string()).ok();

            let relative_collision_point: f32 = pong_ball_transform.position.y - racket_transform.position.y;
            let rebound_angle: f32 = relative_collision_point * 1.0 + random_factor;

            let pong_ball_new_velocity: Vector2<f32>;

            if racket_transform.position.x > 0.0 {
                pong_ball_new_velocity = Vector2::new(-1.0, rebound_angle).normalize() * pong_ball_velocity.to_vec().magnitude();
                pong_ball_velocity.x = pong_ball_new_velocity.x; pong_ball_velocity.y = pong_ball_new_velocity.y;
                pong_ball_transform.position.x -= 0.1;
            } else if racket_transform.position.x < 0.0 {
                pong_ball_new_velocity = Vector2::new(1.0, rebound_angle).normalize() * pong_ball_velocity.to_vec().magnitude();
                pong_ball_velocity.x = pong_ball_new_velocity.x; pong_ball_velocity.y = pong_ball_new_velocity.y;
                pong_ball_transform.position.x += 0.1;
            }
            let new_position: Vector2<f32> = Vector2::new(pong_ball_transform.position.x, pong_ball_transform.position.y);
            pong_ball_transform.set_position(&context.render_state, new_position);
        }
    }
}

fn check_borders_ball_collision(context: &mut Context, pong_ball: &Entity, random_factor: f32) {
    let mut border_query: Query = Query::new(&context.world).with::<Border>();
    let borders: Vec<Entity> = border_query.entities_with_components().unwrap();

    for border in &borders {
        let border_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(border).unwrap();
        let border_transform: ComponentRef<'_, Transform> = context.world.get_entity_component::<Transform>(border).unwrap();

        let pong_ball_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(&pong_ball).unwrap();
        let mut pong_ball_velocity: ComponentRefMut<'_, Velocity> = context.world.get_entity_component_mut::<Velocity>(&pong_ball).unwrap();
        let mut pong_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&pong_ball).unwrap();

        let pong_ball_new_velocity: Vector2<f32>;

        if Collision::check(CollisionAlgorithm::Aabb, &border_collision, &pong_ball_collision) {
            if border_transform.position.y > 0.0 {
                pong_ball_new_velocity = Vector2::new(pong_ball_velocity.x.signum(), -1.0 + random_factor).normalize() * pong_ball_velocity.to_vec().magnitude();
                pong_ball_velocity.x = pong_ball_new_velocity.x; pong_ball_velocity.y = pong_ball_new_velocity.y;
                pong_ball_transform.position.y -= 0.1;
            } else if border_transform.position.y < 0.0 {
                pong_ball_new_velocity = Vector2::new(pong_ball_velocity.x.signum(), 1.0 + random_factor).normalize() * pong_ball_velocity.to_vec().magnitude();
                pong_ball_velocity.x = pong_ball_new_velocity.x; pong_ball_velocity.y = pong_ball_new_velocity.y;
                pong_ball_transform.position.y += 0.1;
            }
            let new_position: Vector2<f32> = Vector2::new(pong_ball_transform.position.x, pong_ball_transform.position.y);
            pong_ball_transform.set_position(&context.render_state, new_position);
        }
    }
}

fn respawn_pong_ball_after_outbounds(context: &mut Context, pong_ball: &Entity) {
    let mut pong_ball_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(pong_ball).unwrap();
    let position_default: Vector2<f32> = Vector2::new(0.0, 0.0);

    if pong_ball_transform.position.x > 2.0 || pong_ball_transform.position.x < -2.0 {
        let mut pong_ball_respawn_timer: ResourceRefMut<'_, PongBallRespawnTimer> = context.world.get_resource_mut::<PongBallRespawnTimer>().unwrap();
        pong_ball_respawn_timer.0.tick(context.delta);

        if pong_ball_respawn_timer.0.is_finished() {
            pong_ball_transform.set_position(&context.render_state, position_default);
        }
    }
}

pub fn set_position_x(&mut self, render_state: &RenderState, x: f32)

Set the curretn position x and sends it to the buffer.

Examples found in repository

examples/breakout.rs (line 231)

fn move_player(context: &mut Context, input: Input, player_entity: Entity) {
    let mut player_transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut(&player_entity).unwrap();
    let player_velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component(&player_entity).unwrap();

    if input.is_key_pressed(KeyCode::ArrowRight) {
        let x: f32 = player_transform.position.x + player_velocity.x * context.delta;
        player_transform.set_position_x(&context.render_state, x);
    } else if input.is_key_pressed(KeyCode::ArrowLeft) {
        let x: f32 = player_transform.position.x - player_velocity.x * context.delta;
        player_transform.set_position_x(&context.render_state, x);
    }
}

examples/simple_camera.rs (line 80)

fn update(context: &mut Context) {
    let input: ResourceRef<'_, Input> = context.world.get_resource::<Input>().unwrap();

    let mut query: Query = Query::new(&context.world).with::<Sprite>().with::<Velocity>();
    let player_entity: Entity = query.entities_with_components().unwrap().first().unwrap().clone();

    let mut camera2d: ResourceRefMut<'_, Camera2d> = context.world.get_resource_mut::<Camera2d>().unwrap();
    camera2d.set_target(player_entity);

    let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(&player_entity).unwrap();
    let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&player_entity).unwrap();

    if input.is_key_pressed(KeyCode::ArrowRight) {
        let x: f32 = transform.position.x + velocity.x * context.delta;
        transform.set_position_x(&context.render_state, x);
    } else if input.is_key_pressed(KeyCode::ArrowLeft) {
        let x: f32 = transform.position.x - velocity.x * context.delta;
        transform.set_position_x(&context.render_state, x);
    }
}

examples/player_animation.rs (line 89)

fn move_player(context: &mut Context, input: Input) {
    let mut query: Query = Query::new(&context.world).with::<Animation>();
    let result: Entity = query.entities_with_components().unwrap().first().unwrap().clone();
    let mut animation: ComponentRefMut<'_, Animation> = context.world.get_entity_component_mut::<Animation>(&result).unwrap();
    let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&result).unwrap();
    let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(&result).unwrap();

    if input.is_key_pressed(KeyCode::KeyW) {
        let y: f32 = transform.position.y + velocity.y * context.delta;
        transform.set_position_y(&context.render_state, y);
    } else if input.is_key_pressed(KeyCode::KeyS) {
        let y: f32 = transform.position.y - velocity.y * context.delta;
        transform.set_position_y(&context.render_state, y);
    } else if input.is_key_pressed(KeyCode::KeyD) {
        let x: f32 = transform.position.x + velocity.x * context.delta;
        transform.set_position_x(&context.render_state, x);
    } else if input.is_key_pressed(KeyCode::KeyA) {
        let x: f32 = transform.position.x - velocity.x * context.delta;
        transform.set_position_x(&context.render_state, x);
    }

    if input.is_some_of_keys_pressed(vec![KeyCode::KeyW, KeyCode::KeyS, KeyCode::KeyA, KeyCode::KeyD]) {
        animation.play("walk".to_string());
    }

    if input.is_some_of_keys_released(vec![KeyCode::KeyW, KeyCode::KeyS, KeyCode::KeyA, KeyCode::KeyD]) {
        animation.stop("walk".to_string());
    }
}

pub fn set_position_y(&mut self, render_state: &RenderState, y: f32)

Set the curretn position y and sends it to the buffer.

Examples found in repository

examples/gravity_simulation.rs (line 78)

fn check_table_object_collision(context: &mut Context) {
    let mut table_query: Query = Query::new(&context.world).with::<RigidBody>();
    let mut object_query: Query = Query::new(&context.world).with::<RigidBody>();

    let table: Entity = table_query.entities_without_components().unwrap().first().unwrap().clone();
    let object: Entity = object_query.entities_with_components().unwrap().first().unwrap().clone();

    let table_collision: ComponentRef<'_, Collision> = context.world.get_entity_component::<Collision>(&table).unwrap();

    let (object_collision, mut object_transform, mut object_velocity, mut object_rigid_body) = (
        context.world.get_entity_component::<Collision>(&object).unwrap(),
        context.world.get_entity_component_mut::<Transform>(&object).unwrap(),
        context.world.get_entity_component_mut::<Velocity>(&object).unwrap(),
        context.world.get_entity_component_mut::<RigidBody>(&object).unwrap()
    );

    if Collision::check(CollisionAlgorithm::Aabb, &table_collision, &object_collision) {
        if object_velocity.y < -0.001 {
            object_velocity.y = -object_velocity.y * object_rigid_body.restitution;
            let y: f32 = object_transform.position.y + object_velocity.y * context.delta;
            object_transform.set_position_y(&context.render_state, y);
        } else {
            object_velocity.y = 0.0;
            object_rigid_body.rest = true;
        }
    }
}

examples/player_animation.rs (line 83)

fn move_player(context: &mut Context, input: Input) {
    let mut query: Query = Query::new(&context.world).with::<Animation>();
    let result: Entity = query.entities_with_components().unwrap().first().unwrap().clone();
    let mut animation: ComponentRefMut<'_, Animation> = context.world.get_entity_component_mut::<Animation>(&result).unwrap();
    let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(&result).unwrap();
    let velocity: ComponentRef<'_, Velocity> = context.world.get_entity_component::<Velocity>(&result).unwrap();

    if input.is_key_pressed(KeyCode::KeyW) {
        let y: f32 = transform.position.y + velocity.y * context.delta;
        transform.set_position_y(&context.render_state, y);
    } else if input.is_key_pressed(KeyCode::KeyS) {
        let y: f32 = transform.position.y - velocity.y * context.delta;
        transform.set_position_y(&context.render_state, y);
    } else if input.is_key_pressed(KeyCode::KeyD) {
        let x: f32 = transform.position.x + velocity.x * context.delta;
        transform.set_position_x(&context.render_state, x);
    } else if input.is_key_pressed(KeyCode::KeyA) {
        let x: f32 = transform.position.x - velocity.x * context.delta;
        transform.set_position_x(&context.render_state, x);
    }

    if input.is_some_of_keys_pressed(vec![KeyCode::KeyW, KeyCode::KeyS, KeyCode::KeyA, KeyCode::KeyD]) {
        animation.play("walk".to_string());
    }

    if input.is_some_of_keys_released(vec![KeyCode::KeyW, KeyCode::KeyS, KeyCode::KeyA, KeyCode::KeyD]) {
        animation.stop("walk".to_string());
    }
}

pub fn set_position_pixelated( &mut self, render_state: &RenderState, position: Vector2<f32>, )

Set the current position and sends it to the buffer.

Useful to set a brand new position using pixelated values.

Your pixelated coordinate will be normalized.

pub fn set_position_x_pixelated(&mut self, render_state: &RenderState, x: f32)

Set the curretn position x and sends it to the buffer.

Useful to set a brand new position x using pixelated values.

Your pixelated coordinate will be normalized.

pub fn set_position_y_pixelated(&mut self, render_state: &RenderState, y: f32)

Set the curretn position y and sends it to the buffer.

Useful to set a brand new position y using pixelated values.

Your pixelated coordinate will be normalized.

pub fn get_position(&self) -> Vector2<f32>

Get the current position.

pub fn rotation(self, rotation: f32) -> Self

Set the rotation on initialization.

pub fn set_rotation(&mut self, render_state: &RenderState, rotation: f32)

Set the current rotation and sends it to the buffer.

Examples found in repository

examples/simple_shapes.rs (line 89)

fn update(context: &mut Context) {
    context.commands.show_fps(context.game_loop_listener.current_fps, Color::BLACK);

    let mut query: Query = Query::new(&context.world).with::<Shape>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();

    for entity in &entities {
        let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(entity).unwrap();
        let rotation: f32 = transform.get_rotation() + 100.0 * context.delta;
        transform.set_rotation(&context.render_state, rotation);
    }
}

pub fn get_rotation(&self) -> f32

Get the current rotation.

Examples found in repository

examples/simple_shapes.rs (line 88)

fn update(context: &mut Context) {
    context.commands.show_fps(context.game_loop_listener.current_fps, Color::BLACK);

    let mut query: Query = Query::new(&context.world).with::<Shape>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();

    for entity in &entities {
        let mut transform: ComponentRefMut<'_, Transform> = context.world.get_entity_component_mut::<Transform>(entity).unwrap();
        let rotation: f32 = transform.get_rotation() + 100.0 * context.delta;
        transform.set_rotation(&context.render_state, rotation);
    }
}

pub fn scale(self, scale: Vector2<f32>) -> Self

Set the scale on initialization.

pub fn set_scale(&mut self, render_state: &RenderState, scale: Vector2<f32>)

Set the current scale and sends it to the buffer.

pub fn get_scale(&self) -> Vector2<f32>

Get the current scale.

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Transform

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Self

Returns a default transform struct.