Feature request: Methods for getting components of vector as same type

[sullyj3]

eg

impl Vec2 {
    fn x_component(&self) -> Self {
        self.x * Self::X
    }
}

And similar for all components for all applicable vector types.

The motivation was to make intent slightly clearer in code like the following bevy system:

pub fn draw_aabbs(
    mut lines: ResMut<DebugLines>,
    q: Query<(&Transform, &AABB), With<DrawAABB>>,
) {
    for (transform, AABB { scale }) in q.iter() {
        // determine coordinates for drawing aabb
        let the_scale: Vec3 = scale.extend(0.);

        // before change
        let top_left: Vec3 = transform.translation - the_scale / 2.;
        let top_right: Vec3 = top_left + the_scale.x * Vec3::X;
        let bottom_left: Vec3 = top_left + the_scale.y * Vec3::Y;
        let bottom_right: Vec3 = top_left + the_scale;
        
        // after change
        let top_left: Vec3 = transform.translation - the_scale / 2.;
        let top_right: Vec3 = top_left + the_scale.x_component();
        let bottom_left: Vec3 = top_left + the_scale.y_component();
        let bottom_right: Vec3 = top_left + the_scale;

        lines.line_colored(top_left, top_right, 0.0, Color::GREEN);
        lines.line_colored(top_right, bottom_right, 0.0, Color::GREEN);
        lines.line_colored(bottom_right, bottom_left, 0.0, Color::GREEN);
        lines.line_colored(bottom_left, top_left, 0.0, Color::GREEN);
    }
}

Would you accept a PR along these lines?

Another alternative would be a trait based approach, like so:

pub trait HasX {
    fn x_component(&self) -> Self
    where
        Self: Sized;
}

impl HasX for Vec2 {
    fn x_component(&self) -> Self {
        self.x * Self::X
    }
}

impl HasX for Vec3 {
    fn x_component(&self) -> Self {
        self.x * Self::X
    }
}

// etc

[sullyj3]

Here's an implementation of the trait based approach

[bitshifter]

Moved to discussions as I prefer to deal with feature suggestions this way.

For this one I'm inclined to not add this. In part, I think it would be hard to come up with a meaningful method name that clearly documents what it does. It's also not a huge saving for users.

Implementation wise it is cheaper to do

let top_left: Vec3 = transform.translation - the_scale / 2.;
let top_right: Vec3 = top_left + Vec3::new(the_scale.x, 0.0, 0.0);
let bottom_left: Vec3 = top_left + Vec3::new(0.0, the_scale.y, 0.0);
let bottom_right: Vec3 = top_left + the_scale;

[sullyj3]

No worries! Yeah, that's a clear alternative