Struct UVec2 

#[repr(C)]
pub struct UVec2 {
    pub x: u32,
    pub y: u32,
}

A 2-dimensional vector.

Fields

x: u32

y: u32

Implementations

impl UVec2

pub const ZERO: UVec2

All zeroes.

pub const ONE: UVec2

All ones.

pub const MIN: UVec2

All u32::MIN.

pub const MAX: UVec2

All u32::MAX.

pub const X: UVec2

A unit vector pointing along the positive X axis.

pub const Y: UVec2

A unit vector pointing along the positive Y axis.

pub const AXES: [UVec2; 2]

The unit axes.

pub const fn new(x: u32, y: u32) -> UVec2

Creates a new vector.

Examples found in repository

examples/shader/compute_shader_game_of_life.rs (line 29)

const SIZE: UVec2 = UVec2::new(1280 / DISPLAY_FACTOR, 720 / DISPLAY_FACTOR);

examples/window/persisting_window_settings.rs (lines 121-124)

fn store_window_settings(mut window_settings: ResMut<WindowSettings>, window: &Window) -> bool {
    window_settings.set_if_neq(WindowSettings {
        position: match window.position {
            WindowPosition::At(pos) => Some(pos),
            _ => None,
        },
        size: Some(UVec2::new(
            window.resolution.width() as u32,
            window.resolution.height() as u32,
        )),
        fullscreen: window.mode != WindowMode::Windowed,
    })
}

examples/window/custom_cursor_image.rs (line 201)

    const SECTIONS: [Option<URect>; 5] = [
        Some(URect {
            min: UVec2::ZERO,
            max: UVec2::splat(RECT_SIZE),
        }),
        Some(URect {
            min: UVec2::new(RECT_SIZE, 0),
            max: UVec2::new(2 * RECT_SIZE, RECT_SIZE),
        }),
        Some(URect {
            min: UVec2::new(0, RECT_SIZE),
            max: UVec2::new(RECT_SIZE, 2 * RECT_SIZE),
        }),
        Some(URect {
            min: UVec2::new(RECT_SIZE, RECT_SIZE),
            max: UVec2::splat(2 * RECT_SIZE),
        }),
        None, // reset to None
    ];

examples/2d/tilemap_chunk.rs (line 76)

fn spawn_fake_player(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
    chunk: Single<&TilemapChunk>,
) {
    let mut transform = chunk.calculate_tile_transform(UVec2::new(0, 0));
    transform.translation.z = 1.;

    commands.spawn((
        Mesh2d(meshes.add(Rectangle::new(8., 8.))),
        MeshMaterial2d(materials.add(Color::from(RED_400))),
        transform,
        MovePlayer,
    ));

    let mut transform = chunk.calculate_tile_transform(UVec2::new(5, 6));
    transform.translation.z = 1.;

    // second "player" to visually test a non-zero position
    commands.spawn((
        Mesh2d(meshes.add(Rectangle::new(8., 8.))),
        MeshMaterial2d(materials.add(Color::from(RED_400))),
        transform,
    ));
}

fn move_player(
    mut player: Single<&mut Transform, With<MovePlayer>>,
    time: Res<Time>,
    chunk: Single<&TilemapChunk>,
) {
    let t = (ops::sin(time.elapsed_secs()) + 1.) / 2.;

    let origin = chunk
        .calculate_tile_transform(UVec2::new(0, 0))
        .translation
        .x;
    let destination = chunk
        .calculate_tile_transform(UVec2::new(63, 0))
        .translation
        .x;

    player.translation.x = origin.lerp(destination, t);
}

fn update_tilemap(
    time: Res<Time>,
    mut query: Query<(&mut TilemapChunkTileData, &mut UpdateTimer)>,
    mut rng: ResMut<SeededRng>,
) {
    for (mut tile_data, mut timer) in query.iter_mut() {
        timer.tick(time.delta());

        if timer.just_finished() {
            for _ in 0..50 {
                let index = rng.random_range(0..tile_data.len());
                tile_data[index] = Some(TileData::from_tileset_index(rng.random_range(0..5)));
            }
        }
    }
}

// find the data for an arbitrary tile in the chunk and log its data
fn log_tile(tilemap: Single<(&TilemapChunk, &TilemapChunkTileData)>, mut local: Local<u16>) {
    let (chunk, data) = tilemap.into_inner();
    let Some(tile_data) = data.tile_data_from_tile_pos(chunk.chunk_size, UVec2::new(3, 4)) else {
        return;
    };
    // log when the tile changes
    if tile_data.tileset_index != *local {
        info!(?tile_data, "tile_data changed");
        *local = tile_data.tileset_index;
    }
}

examples/testbed/2d.rs (line 422)

    pub fn draw_gizmos(mut gizmos: Gizmos) {
        gizmos.rect_2d(
            Isometry2d::from_translation(Vec2::new(-200.0, 0.0)),
            Vec2::new(200.0, 200.0),
            RED,
        );
        gizmos
            .circle_2d(
                Isometry2d::from_translation(Vec2::new(-200.0, 0.0)),
                200.0,
                GREEN,
            )
            .resolution(64);

        gizmos.text_2d(
            Isometry2d::from_translation(Vec2::new(-200.0, 0.0)),
            "text_2d gizmo",
            15.,
            Vec2 { x: 0., y: 0. },
            Color::WHITE,
        );

        // 2d grids with all variations of outer edges on or off
        for i in 0..4 {
            let x = 200.0 * (1.0 + (i % 2) as f32);
            let y = 150.0 * (0.5 - (i / 2) as f32);
            let mut grid = gizmos.grid(
                Vec3::new(x, y, 0.0),
                UVec2::new(5, 4),
                Vec2::splat(30.),
                Color::WHITE,
            );
            if i & 1 > 0 {
                grid = grid.outer_edges_x();
            }
            if i & 2 > 0 {
                grid.outer_edges_y();
            }
        }
    }

examples/picking/sprite_picking.rs (line 128)

fn setup_atlas(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
) {
    let texture_handle = asset_server.load("textures/rpg/chars/gabe/gabe-idle-run.png");
    let layout = TextureAtlasLayout::from_grid(UVec2::new(24, 24), 7, 1, None, None);
    let texture_atlas_layout_handle = texture_atlas_layouts.add(layout);
    // Use only the subset of sprites in the sheet that make up the run animation
    let animation_indices = AnimationIndices { first: 1, last: 6 };
    commands
        .spawn((
            Sprite::from_atlas_image(
                texture_handle,
                TextureAtlas {
                    layout: texture_atlas_layout_handle,
                    index: animation_indices.first,
                },
            ),
            Transform::from_xyz(300.0, 0.0, 0.0).with_scale(Vec3::splat(6.0)),
            animation_indices,
            AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
            Pickable::default(),
        ))
        .observe(recolor_on::<Pointer<Over>>(Color::srgb(0.0, 1.0, 1.0)))
        .observe(recolor_on::<Pointer<Out>>(Color::srgb(1.0, 1.0, 1.0)))
        .observe(recolor_on::<Pointer<Press>>(Color::srgb(1.0, 1.0, 0.0)))
        .observe(recolor_on::<Pointer<Release>>(Color::srgb(0.0, 1.0, 1.0)));
}

Additional examples can be found in:

• examples/shader/automatic_instancing.rs
• examples/stress_tests/many_cameras_lights.rs
• examples/ui/images/ui_texture_atlas_slice.rs
• examples/gizmos/2d_gizmos.rs
• examples/2d/2d_viewport_to_world.rs
• examples/gizmos/3d_gizmos.rs
• examples/testbed/3d.rs
• examples/3d/split_screen.rs
• examples/2d/texture_atlas.rs
• examples/3d/camera_sub_view.rs

pub const fn splat(v: u32) -> UVec2

Creates a vector with all elements set to v.

Examples found in repository

examples/testbed/2d.rs (line 445)

    const ATLAS_SIZE: UVec2 = UVec2::splat(64);
    const IMAGE_SIZE: UVec2 = UVec2::splat(28);
    const PADDING_SIZE: UVec2 = UVec2::splat(2);

examples/2d/dynamic_mip_generation.rs (line 412)

    fn next(&mut self) -> Option<Self::Item> {
        // The size of mipmap level N + 1 is equal to half the size of mipmap
        // level N, rounding down, except that the size can never go below 1
        // pixel on either axis.
        let result = self.size;
        if let Some(size) = self.size {
            self.size = if size == UVec2::splat(1) {
                None
            } else {
                Some((size / 2).max(UVec2::splat(1)))
            };
        }
        result
    }

examples/2d/sprite_sheet.rs (line 48)

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
) {
    let texture = asset_server.load("textures/rpg/chars/gabe/gabe-idle-run.png");
    let layout = TextureAtlasLayout::from_grid(UVec2::splat(24), 7, 1, None, None);
    let texture_atlas_layout = texture_atlas_layouts.add(layout);
    // Use only the subset of sprites in the sheet that make up the run animation
    let animation_indices = AnimationIndices { first: 1, last: 6 };

    commands.spawn(Camera2d);

    commands.spawn((
        Sprite::from_atlas_image(
            texture,
            TextureAtlas {
                layout: texture_atlas_layout,
                index: animation_indices.first,
            },
        ),
        Transform::from_scale(Vec3::splat(6.0)),
        animation_indices,
        AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
    ));
}

examples/shader_advanced/render_depth_to_texture.rs (line 255)

fn spawn_depth_only_camera(commands: &mut Commands) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(-4.0, -5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
        Camera {
            // Make sure that we render from this depth-only camera *before*
            // rendering from the main camera.
            order: -1,
            ..Camera::default()
        },
        // We specify no color render target, for maximum efficiency.
        RenderTarget::None {
            // When specifying no render target, we must manually specify
            // the viewport size. Otherwise, Bevy won't know how big to make
            // the depth buffer.
            size: UVec2::splat(DEPTH_TEXTURE_SIZE),
        },
        // We need to disable multisampling or the depth texture will be
        // multisampled, which adds complexity we don't care about for this
        // demo.
        Msaa::Off,
        // Cameras with no render target render *nothing* by default. To get
        // them to render something, we must add a prepass that specifies what
        // we want to render: in this case, depth.
        DepthPrepass,
    ));
}

examples/window/custom_cursor_image.rs (line 38)

fn setup_cursor_icon(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
    window: Single<Entity, With<Window>>,
) {
    let layout =
        TextureAtlasLayout::from_grid(UVec2::splat(64), 20, 10, Some(UVec2::splat(5)), None);
    let texture_atlas_layout = texture_atlas_layouts.add(layout);

    let animation_config = AnimationConfig::new(0, 199, 1, 4);

    commands.entity(*window).insert((
        CursorIcon::Custom(CustomCursor::Image(CustomCursorImage {
            // Image to use as the cursor.
            handle: asset_server
                .load("cursors/kenney_crosshairPack/Tilesheet/crosshairs_tilesheet_white.png"),
            // Optional texture atlas allows you to pick a section of the image
            // and animate it.
            texture_atlas: Some(TextureAtlas {
                layout: texture_atlas_layout.clone(),
                index: animation_config.first_sprite_index,
            }),
            flip_x: false,
            flip_y: false,
            // Optional section of the image to use as the cursor.
            rect: None,
            // The hotspot is the point in the cursor image that will be
            // positioned at the mouse cursor's position.
            hotspot: (0, 0),
        })),
        animation_config,
    ));
}

fn setup_camera(mut commands: Commands) {
    commands.spawn(Camera3d::default());
}

fn setup_instructions(mut commands: Commands) {
    commands.spawn((
        Text::new(
            "Press T to toggle the cursor's `texture_atlas`.\n
Press X to toggle the cursor's `flip_x` setting.\n
Press Y to toggle the cursor's `flip_y` setting.\n
Press C to cycle through the sections of the cursor's image using `rect`.",
        ),
        Node {
            position_type: PositionType::Absolute,
            bottom: px(12),
            left: px(12),
            ..default()
        },
    ));
}

#[derive(Component)]
struct AnimationConfig {
    first_sprite_index: usize,
    last_sprite_index: usize,
    increment: usize,
    fps: u8,
    frame_timer: Timer,
}

impl AnimationConfig {
    fn new(first: usize, last: usize, increment: usize, fps: u8) -> Self {
        Self {
            first_sprite_index: first,
            last_sprite_index: last,
            increment,
            fps,
            frame_timer: Self::timer_from_fps(fps),
        }
    }

    fn timer_from_fps(fps: u8) -> Timer {
        Timer::new(Duration::from_secs_f32(1.0 / (fps as f32)), TimerMode::Once)
    }
}

/// This system loops through all the sprites in the [`CursorIcon`]'s
/// [`TextureAtlas`], from [`AnimationConfig`]'s `first_sprite_index` to
/// `last_sprite_index`.
fn execute_animation(time: Res<Time>, mut query: Query<(&mut AnimationConfig, &mut CursorIcon)>) {
    for (mut config, mut cursor_icon) in &mut query {
        if let CursorIcon::Custom(CustomCursor::Image(ref mut image)) = *cursor_icon {
            config.frame_timer.tick(time.delta());

            if config.frame_timer.is_finished()
                && let Some(atlas) = image.texture_atlas.as_mut()
            {
                atlas.index += config.increment;

                if atlas.index > config.last_sprite_index {
                    atlas.index = config.first_sprite_index;
                }

                config.frame_timer = AnimationConfig::timer_from_fps(config.fps);
            }
        }
    }
}

fn toggle_texture_atlas(
    input: Res<ButtonInput<KeyCode>>,
    mut query: Query<&mut CursorIcon, With<Window>>,
    mut cached_atlas: Local<Option<TextureAtlas>>, // this lets us restore the previous value
) {
    if input.just_pressed(KeyCode::KeyT) {
        for mut cursor_icon in &mut query {
            if let CursorIcon::Custom(CustomCursor::Image(ref mut image)) = *cursor_icon {
                match image.texture_atlas.take() {
                    Some(a) => {
                        // Save the current texture atlas.
                        *cached_atlas = Some(a.clone());
                    }
                    None => {
                        // Restore the cached texture atlas.
                        if let Some(cached_a) = cached_atlas.take() {
                            image.texture_atlas = Some(cached_a);
                        }
                    }
                }
            }
        }
    }
}

fn toggle_flip_x(
    input: Res<ButtonInput<KeyCode>>,
    mut query: Query<&mut CursorIcon, With<Window>>,
) {
    if input.just_pressed(KeyCode::KeyX) {
        for mut cursor_icon in &mut query {
            if let CursorIcon::Custom(CustomCursor::Image(ref mut image)) = *cursor_icon {
                image.flip_x = !image.flip_x;
            }
        }
    }
}

fn toggle_flip_y(
    input: Res<ButtonInput<KeyCode>>,
    mut query: Query<&mut CursorIcon, With<Window>>,
) {
    if input.just_pressed(KeyCode::KeyY) {
        for mut cursor_icon in &mut query {
            if let CursorIcon::Custom(CustomCursor::Image(ref mut image)) = *cursor_icon {
                image.flip_y = !image.flip_y;
            }
        }
    }
}

/// This system alternates the [`CursorIcon`]'s `rect` field between `None` and
/// 4 sections/rectangles of the cursor's image.
fn cycle_rect(input: Res<ButtonInput<KeyCode>>, mut query: Query<&mut CursorIcon, With<Window>>) {
    if !input.just_pressed(KeyCode::KeyC) {
        return;
    }

    const RECT_SIZE: u32 = 32; // half the size of a tile in the texture atlas

    const SECTIONS: [Option<URect>; 5] = [
        Some(URect {
            min: UVec2::ZERO,
            max: UVec2::splat(RECT_SIZE),
        }),
        Some(URect {
            min: UVec2::new(RECT_SIZE, 0),
            max: UVec2::new(2 * RECT_SIZE, RECT_SIZE),
        }),
        Some(URect {
            min: UVec2::new(0, RECT_SIZE),
            max: UVec2::new(RECT_SIZE, 2 * RECT_SIZE),
        }),
        Some(URect {
            min: UVec2::new(RECT_SIZE, RECT_SIZE),
            max: UVec2::splat(2 * RECT_SIZE),
        }),
        None, // reset to None
    ];

examples/2d/tilemap_chunk.rs (line 31)

fn setup(mut commands: Commands, assets: Res<AssetServer>) {
    // We're seeding the PRNG here to make this example deterministic for testing purposes.
    // This isn't strictly required in practical use unless you need your app to be deterministic.
    let mut rng = ChaCha8Rng::seed_from_u64(42);

    let chunk_size = UVec2::splat(64);
    let tile_display_size = UVec2::splat(8);
    let tile_data: Vec<Option<TileData>> = (0..chunk_size.element_product())
        .map(|_| rng.random_range(0..5))
        .map(|i| {
            if i == 0 {
                None
            } else {
                Some(TileData::from_tileset_index(i - 1))
            }
        })
        .collect();

    commands.spawn((
        TilemapChunk {
            chunk_size,
            tile_display_size,
            tileset: assets
                .load_builder()
                .with_settings(|settings: &mut ImageLoaderSettings| {
                    // The tileset texture is expected to be an array of tile textures, so we tell the
                    // `ImageLoader` that our texture is composed of 4 stacked tile images.
                    settings.array_layout = Some(ImageArrayLayout::RowCount { rows: 4 });
                })
                .load("textures/array_texture.png"),
            ..default()
        },
        TilemapChunkTileData(tile_data),
        UpdateTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
    ));

    commands.spawn(Camera2d);

    commands.insert_resource(SeededRng(rng));
}

Additional examples can be found in:

• examples/usage/cooldown.rs
• examples/ui/images/ui_texture_atlas.rs
• examples/stress_tests/many_animated_sprites.rs
• examples/stress_tests/many_animated_sprite_meshes.rs
• examples/2d/sprite_animation.rs
• examples/2d/tilemap_chunk_orientation.rs
• examples/ui/images/ui_texture_atlas_slice.rs
• examples/gizmos/3d_gizmos.rs
• examples/2d/sprite_scale.rs

pub fn map<F>(self, f: F) -> UVec2

where F: Fn(u32) -> u32,

Returns a vector containing each element of self modified by a mapping function f.

pub fn select(mask: BVec2, if_true: UVec2, if_false: UVec2) -> UVec2

Creates a vector from the elements in if_true and if_false, selecting which to use for each element of self.

A true element in the mask uses the corresponding element from if_true, and false uses the element from if_false.

pub const fn from_array(a: [u32; 2]) -> UVec2

Creates a new vector from an array.

pub const fn to_array(&self) -> [u32; 2]

Converts self to [x, y]

pub const fn from_slice(slice: &[u32]) -> UVec2

Creates a vector from the first 2 values in slice.

Panics

Panics if slice is less than 2 elements long.

pub fn write_to_slice(self, slice: &mut [u32])

Writes the elements of self to the first 2 elements in slice.

Panics

Panics if slice is less than 2 elements long.

pub const fn extend(self, z: u32) -> UVec3

Creates a 3D vector from self and the given z value.

pub fn with_x(self, x: u32) -> UVec2

Creates a 2D vector from self with the given value of x.

pub fn with_y(self, y: u32) -> UVec2

Creates a 2D vector from self with the given value of y.

pub fn dot(self, rhs: UVec2) -> u32

Computes the dot product of self and rhs.

pub fn dot_into_vec(self, rhs: UVec2) -> UVec2

Returns a vector where every component is the dot product of self and rhs.

pub fn min(self, rhs: UVec2) -> UVec2

Returns a vector containing the minimum values for each element of self and rhs.

In other words this computes [min(x, rhs.x), min(self.y, rhs.y), ..].

Examples found in repository

examples/2d/2d_viewport_to_world.rs (line 102)

fn controls(
    camera_query: Single<(&mut Camera, &mut Transform, &mut Projection)>,
    window: Single<&Window>,
    input: Res<ButtonInput<KeyCode>>,
    time: Res<Time<Fixed>>,
) {
    let (mut camera, mut transform, mut projection) = camera_query.into_inner();

    let fspeed = 600.0 * time.delta_secs();
    let uspeed = fspeed as u32;
    let window_size = window.resolution.physical_size();

    // Camera movement controls
    if input.pressed(KeyCode::ArrowUp) {
        transform.translation.y += fspeed;
    }
    if input.pressed(KeyCode::ArrowDown) {
        transform.translation.y -= fspeed;
    }
    if input.pressed(KeyCode::ArrowLeft) {
        transform.translation.x -= fspeed;
    }
    if input.pressed(KeyCode::ArrowRight) {
        transform.translation.x += fspeed;
    }

    // Camera zoom controls
    if let Projection::Orthographic(projection2d) = &mut *projection {
        if input.pressed(KeyCode::Comma) {
            projection2d.scale *= powf(4.0f32, time.delta_secs());
        }

        if input.pressed(KeyCode::Period) {
            projection2d.scale *= powf(0.25f32, time.delta_secs());
        }
    }

    if let Some(viewport) = camera.viewport.as_mut() {
        // Reset viewport size on window resize
        if viewport.physical_size.x > window_size.x || viewport.physical_size.y > window_size.y {
            viewport.physical_size = (window_size.as_vec2() * 0.75).as_uvec2();
        }

        // Viewport movement controls
        if input.pressed(KeyCode::KeyW) {
            viewport.physical_position.y = viewport.physical_position.y.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyS) {
            viewport.physical_position.y += uspeed;
        }
        if input.pressed(KeyCode::KeyA) {
            viewport.physical_position.x = viewport.physical_position.x.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyD) {
            viewport.physical_position.x += uspeed;
        }

        // Bound viewport position so it doesn't go off-screen
        viewport.physical_position = viewport
            .physical_position
            .min(window_size - viewport.physical_size);

        // Viewport size controls
        if input.pressed(KeyCode::KeyI) {
            viewport.physical_size.y = viewport.physical_size.y.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyK) {
            viewport.physical_size.y += uspeed;
        }
        if input.pressed(KeyCode::KeyJ) {
            viewport.physical_size.x = viewport.physical_size.x.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyL) {
            viewport.physical_size.x += uspeed;
        }

        // Bound viewport size so it doesn't go off-screen
        viewport.physical_size = viewport
            .physical_size
            .min(window_size - viewport.physical_position)
            .max(UVec2::new(20, 20));
    }
}

pub fn max(self, rhs: UVec2) -> UVec2

Returns a vector containing the maximum values for each element of self and rhs.

In other words this computes [max(self.x, rhs.x), max(self.y, rhs.y), ..].

Examples found in repository

examples/2d/dynamic_mip_generation.rs (line 415)

    fn next(&mut self) -> Option<Self::Item> {
        // The size of mipmap level N + 1 is equal to half the size of mipmap
        // level N, rounding down, except that the size can never go below 1
        // pixel on either axis.
        let result = self.size;
        if let Some(size) = self.size {
            self.size = if size == UVec2::splat(1) {
                None
            } else {
                Some((size / 2).max(UVec2::splat(1)))
            };
        }
        result
    }

examples/2d/2d_viewport_to_world.rs (line 122)

fn controls(
    camera_query: Single<(&mut Camera, &mut Transform, &mut Projection)>,
    window: Single<&Window>,
    input: Res<ButtonInput<KeyCode>>,
    time: Res<Time<Fixed>>,
) {
    let (mut camera, mut transform, mut projection) = camera_query.into_inner();

    let fspeed = 600.0 * time.delta_secs();
    let uspeed = fspeed as u32;
    let window_size = window.resolution.physical_size();

    // Camera movement controls
    if input.pressed(KeyCode::ArrowUp) {
        transform.translation.y += fspeed;
    }
    if input.pressed(KeyCode::ArrowDown) {
        transform.translation.y -= fspeed;
    }
    if input.pressed(KeyCode::ArrowLeft) {
        transform.translation.x -= fspeed;
    }
    if input.pressed(KeyCode::ArrowRight) {
        transform.translation.x += fspeed;
    }

    // Camera zoom controls
    if let Projection::Orthographic(projection2d) = &mut *projection {
        if input.pressed(KeyCode::Comma) {
            projection2d.scale *= powf(4.0f32, time.delta_secs());
        }

        if input.pressed(KeyCode::Period) {
            projection2d.scale *= powf(0.25f32, time.delta_secs());
        }
    }

    if let Some(viewport) = camera.viewport.as_mut() {
        // Reset viewport size on window resize
        if viewport.physical_size.x > window_size.x || viewport.physical_size.y > window_size.y {
            viewport.physical_size = (window_size.as_vec2() * 0.75).as_uvec2();
        }

        // Viewport movement controls
        if input.pressed(KeyCode::KeyW) {
            viewport.physical_position.y = viewport.physical_position.y.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyS) {
            viewport.physical_position.y += uspeed;
        }
        if input.pressed(KeyCode::KeyA) {
            viewport.physical_position.x = viewport.physical_position.x.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyD) {
            viewport.physical_position.x += uspeed;
        }

        // Bound viewport position so it doesn't go off-screen
        viewport.physical_position = viewport
            .physical_position
            .min(window_size - viewport.physical_size);

        // Viewport size controls
        if input.pressed(KeyCode::KeyI) {
            viewport.physical_size.y = viewport.physical_size.y.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyK) {
            viewport.physical_size.y += uspeed;
        }
        if input.pressed(KeyCode::KeyJ) {
            viewport.physical_size.x = viewport.physical_size.x.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyL) {
            viewport.physical_size.x += uspeed;
        }

        // Bound viewport size so it doesn't go off-screen
        viewport.physical_size = viewport
            .physical_size
            .min(window_size - viewport.physical_position)
            .max(UVec2::new(20, 20));
    }
}

pub fn clamp(self, min: UVec2, max: UVec2) -> UVec2

Component-wise clamping of values, similar to u32::clamp.

Each element in min must be less-or-equal to the corresponding element in max.

Panics

Will panic if min is greater than max when glam_assert is enabled.

pub fn min_element(self) -> u32

Returns the horizontal minimum of self.

In other words this computes min(x, y, ..).

pub fn max_element(self) -> u32

Returns the horizontal maximum of self.

In other words this computes max(x, y, ..).

pub fn min_position(self) -> usize

Returns the index of the first minimum element of self.

pub fn max_position(self) -> usize

Returns the index of the first maximum element of self.

pub fn element_sum(self) -> u32

Returns the sum of all elements of self.

In other words, this computes self.x + self.y + ...

pub fn element_product(self) -> u32

Returns the product of all elements of self.

In other words, this computes self.x * self.y * ...

Examples found in repository

examples/2d/tilemap_chunk.rs (line 33)

fn setup(mut commands: Commands, assets: Res<AssetServer>) {
    // We're seeding the PRNG here to make this example deterministic for testing purposes.
    // This isn't strictly required in practical use unless you need your app to be deterministic.
    let mut rng = ChaCha8Rng::seed_from_u64(42);

    let chunk_size = UVec2::splat(64);
    let tile_display_size = UVec2::splat(8);
    let tile_data: Vec<Option<TileData>> = (0..chunk_size.element_product())
        .map(|_| rng.random_range(0..5))
        .map(|i| {
            if i == 0 {
                None
            } else {
                Some(TileData::from_tileset_index(i - 1))
            }
        })
        .collect();

    commands.spawn((
        TilemapChunk {
            chunk_size,
            tile_display_size,
            tileset: assets
                .load_builder()
                .with_settings(|settings: &mut ImageLoaderSettings| {
                    // The tileset texture is expected to be an array of tile textures, so we tell the
                    // `ImageLoader` that our texture is composed of 4 stacked tile images.
                    settings.array_layout = Some(ImageArrayLayout::RowCount { rows: 4 });
                })
                .load("textures/array_texture.png"),
            ..default()
        },
        TilemapChunkTileData(tile_data),
        UpdateTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
    ));

    commands.spawn(Camera2d);

    commands.insert_resource(SeededRng(rng));
}

examples/2d/tilemap_chunk_orientation.rs (line 45)

fn setup(mut commands: Commands, assets: Res<AssetServer>) {
    let chunk_size = UVec2::splat(8);
    let tile_display_size = UVec2::splat(64);

    // We'll use each possible orientation, one per column
    let orientation = [
        TileOrientation::Default,
        TileOrientation::Rotate90,
        TileOrientation::Rotate180,
        TileOrientation::Rotate270,
        TileOrientation::MirrorH,
        TileOrientation::MirrorHRotate90,
        TileOrientation::MirrorHRotate180,
        TileOrientation::MirrorHRotate270,
    ];

    // Show different color/alpha on each row
    let colors = [
        Color::WHITE,
        Color::linear_rgb(1.0, 0.0, 0.0),
        Color::linear_rgb(0.0, 1.0, 0.0),
        Color::linear_rgb(0.0, 0.0, 1.0),
        Color::linear_rgba(1.0, 0.0, 0.0, 0.25),
        Color::linear_rgba(0.0, 1.0, 0.0, 0.25),
        Color::linear_rgba(0.0, 0.0, 1.0, 0.25),
        Color::linear_rgba(1.0, 1.0, 1.0, 0.5),
    ];

    let tile_data = (0..chunk_size.element_product())
        .map(|i| {
            let row = i / 8;
            let col = i % 8;
            Some(TileData {
                // Alternate tiles per row
                tileset_index: (row % 2) as u16,
                color: colors[row as usize],
                // Last (top) row is invisible
                visible: row != 7,
                orientation: orientation[col as usize],
            })
        })
        .collect();

    commands.spawn((
        TilemapChunk {
            chunk_size,
            tile_display_size,
            tileset: assets
                .load_builder()
                .with_settings(|settings: &mut ImageLoaderSettings| {
                    // The tileset texture is expected to be an array of tile textures, so we tell the
                    // `ImageLoader` that our texture is composed of 2 stacked tile images.
                    settings.array_layout = Some(ImageArrayLayout::RowCount { rows: 2 });
                })
                .load("textures/arrow.png"),
            alpha_mode: AlphaMode2d::Blend,
        },
        TilemapChunkTileData(tile_data),
    ));

    commands.spawn(Camera2d);
}

pub fn cmpeq(self, rhs: UVec2) -> BVec2

Returns a vector mask containing the result of a == comparison for each element of self and rhs.

In other words, this computes [self.x == rhs.x, self.y == rhs.y, ..] for all elements.

pub fn cmpne(self, rhs: UVec2) -> BVec2

Returns a vector mask containing the result of a != comparison for each element of self and rhs.

In other words this computes [self.x != rhs.x, self.y != rhs.y, ..] for all elements.

pub fn cmpge(self, rhs: UVec2) -> BVec2

Returns a vector mask containing the result of a >= comparison for each element of self and rhs.

In other words this computes [self.x >= rhs.x, self.y >= rhs.y, ..] for all elements.

pub fn cmpgt(self, rhs: UVec2) -> BVec2

Returns a vector mask containing the result of a > comparison for each element of self and rhs.

In other words this computes [self.x > rhs.x, self.y > rhs.y, ..] for all elements.

pub fn cmple(self, rhs: UVec2) -> BVec2

Returns a vector mask containing the result of a <= comparison for each element of self and rhs.

In other words this computes [self.x <= rhs.x, self.y <= rhs.y, ..] for all elements.

pub fn cmplt(self, rhs: UVec2) -> BVec2

Returns a vector mask containing the result of a < comparison for each element of self and rhs.

In other words this computes [self.x < rhs.x, self.y < rhs.y, ..] for all elements.

pub fn length_squared(self) -> u32

Computes the squared length of self.

pub fn manhattan_distance(self, rhs: UVec2) -> u32

Computes the manhattan distance between two points.

Overflow

This method may overflow if the result is greater than u32::MAX.

See also checked_manhattan_distance.

pub fn checked_manhattan_distance(self, rhs: UVec2) -> Option<u32>

Computes the manhattan distance between two points.

This will returns None if the result is greater than u32::MAX.

pub fn chebyshev_distance(self, rhs: UVec2) -> u32

Computes the chebyshev distance between two points.

pub fn as_vec2(self) -> Vec2

Casts all elements of self to f32.

Examples found in repository

examples/shader/compute_shader_game_of_life.rs (line 65)

fn setup(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
    let mut image = Image::new_target_texture(SIZE.x, SIZE.y, TextureFormat::Rgba32Float, None);
    image.asset_usage = RenderAssetUsages::RENDER_WORLD;
    image.texture_descriptor.usage =
        TextureUsages::COPY_DST | TextureUsages::STORAGE_BINDING | TextureUsages::TEXTURE_BINDING;
    let image0 = images.add(image.clone());
    let image1 = images.add(image);

    commands.spawn((
        Sprite {
            image: image0.clone(),
            custom_size: Some(SIZE.as_vec2()),
            ..default()
        },
        Transform::from_scale(Vec3::splat(DISPLAY_FACTOR as f32)),
    ));
    commands.spawn(Camera2d);

    commands.insert_resource(GameOfLifeImages {
        texture_a: image0,
        texture_b: image1,
    });

    commands.insert_resource(GameOfLifeUniforms {
        alive_color: LinearRgba::RED,
    });
}

examples/2d/dynamic_mip_generation.rs (line 649)

fn spawn_mip_level_views(
    commands: &mut Commands,
    app_status: &AppStatus,
    app_assets: &AppAssets,
    windows_query: &Query<&Window, With<PrimaryWindow>>,
    single_mip_level_materials: &mut Assets<SingleMipLevelMaterial>,
    image_handle: &Handle<Image>,
) {
    let window_size = windows_query.iter().next().unwrap().size();

    // Calculate the placement of the column of mipmap levels.
    let max_slice_size = app_status.max_mip_slice_size(window_size);
    let y_origin = app_status.vertical_mip_slice_origin(window_size);
    let y_spacing = app_status.vertical_mip_slice_spacing(window_size);
    let x_origin = app_status.horizontal_mip_slice_origin(window_size);

    for (mip_level, mip_size) in MipmapSizeIterator::new(app_status).enumerate() {
        let y_center = y_origin - y_spacing * mip_level as f32;

        // Size each image to fit its container, preserving aspect ratio.
        let mut slice_size = mip_size.as_vec2();
        let ratios = max_slice_size / slice_size;
        let slice_scale = ratios.x.min(ratios.y).min(1.0);
        slice_size *= slice_scale;

        // Spawn the image. Use the `SingleMipLevelMaterial` with its custom
        // shader so that only the mip level in question is displayed.
        commands.spawn((
            Mesh2d(app_assets.rectangle.clone()),
            MeshMaterial2d(single_mip_level_materials.add(SingleMipLevelMaterial {
                mip_level: mip_level as u32,
                texture: image_handle.clone(),
            })),
            Transform::from_xyz(x_origin, y_center, 0.0).with_scale(slice_size.extend(1.0)),
            ImageView,
        ));

        // Display a label to the side.
        commands.spawn((
            Text2d::new(format!(
                "Level {}\n{}×{}",
                mip_level, mip_size.x, mip_size.y
            )),
            app_assets.text_font.clone(),
            TextLayout::justify(Justify::Center),
            Text2dShadow::default(),
            Transform::from_xyz(x_origin - max_slice_size.x * 0.5 - 64.0, y_center, 0.0),
            ImageView,
        ));
    }
}

examples/ui/render_ui_to_texture.rs (line 195)

fn drive_diegetic_pointer(
    mut cursor_last: Local<Vec2>,
    mut raycast: MeshRayCast,
    rays: Res<RayMap>,
    cubes: Query<&Mesh3d, With<Cube>>,
    ui_camera: Query<&RenderTarget, With<Camera2d>>,
    primary_window: Query<Entity, With<PrimaryWindow>>,
    windows: Query<(Entity, &Window)>,
    images: Res<Assets<Image>>,
    manual_texture_views: Res<ManualTextureViews>,
    mut window_events: MessageReader<WindowEvent>,
    mut pointer_inputs: MessageWriter<PointerInput>,
) -> Result {
    // Get the size of the texture, so we can convert from dimensionless UV coordinates that span
    // from 0 to 1, to pixel coordinates.
    let target = ui_camera
        .single()?
        .normalize(primary_window.single().ok())
        .unwrap();
    let target_info = target
        .get_render_target_info(windows, &images, &manual_texture_views)
        .unwrap();
    let size = target_info.physical_size.as_vec2();

    // Find raycast hits and update the virtual pointer.
    let raycast_settings = MeshRayCastSettings {
        visibility: RayCastVisibility::VisibleInView,
        filter: &|entity| cubes.contains(entity),
        early_exit_test: &|_| false,
    };
    for (_id, ray) in rays.iter() {
        for (_cube, hit) in raycast.cast_ray(*ray, &raycast_settings) {
            let position = size * hit.uv.unwrap();
            if position != *cursor_last {
                pointer_inputs.write(PointerInput::new(
                    CUBE_POINTER_ID,
                    Location {
                        target: target.clone(),
                        position,
                    },
                    PointerAction::Move {
                        delta: position - *cursor_last,
                    },
                ));
                *cursor_last = position;
            }
        }
    }

    // Pipe pointer button presses to the virtual pointer on the UI texture.
    for window_event in window_events.read() {
        if let WindowEvent::MouseButtonInput(input) = window_event {
            let button = match input.button {
                MouseButton::Left => PointerButton::Primary,
                MouseButton::Right => PointerButton::Secondary,
                MouseButton::Middle => PointerButton::Middle,
                _ => continue,
            };
            let action = match input.state {
                ButtonState::Pressed => PointerAction::Press(button),
                ButtonState::Released => PointerAction::Release(button),
            };
            pointer_inputs.write(PointerInput::new(
                CUBE_POINTER_ID,
                Location {
                    target: target.clone(),
                    position: *cursor_last,
                },
                action,
            ));
        }
    }

    Ok(())
}

examples/2d/2d_viewport_to_world.rs (line 82)

fn controls(
    camera_query: Single<(&mut Camera, &mut Transform, &mut Projection)>,
    window: Single<&Window>,
    input: Res<ButtonInput<KeyCode>>,
    time: Res<Time<Fixed>>,
) {
    let (mut camera, mut transform, mut projection) = camera_query.into_inner();

    let fspeed = 600.0 * time.delta_secs();
    let uspeed = fspeed as u32;
    let window_size = window.resolution.physical_size();

    // Camera movement controls
    if input.pressed(KeyCode::ArrowUp) {
        transform.translation.y += fspeed;
    }
    if input.pressed(KeyCode::ArrowDown) {
        transform.translation.y -= fspeed;
    }
    if input.pressed(KeyCode::ArrowLeft) {
        transform.translation.x -= fspeed;
    }
    if input.pressed(KeyCode::ArrowRight) {
        transform.translation.x += fspeed;
    }

    // Camera zoom controls
    if let Projection::Orthographic(projection2d) = &mut *projection {
        if input.pressed(KeyCode::Comma) {
            projection2d.scale *= powf(4.0f32, time.delta_secs());
        }

        if input.pressed(KeyCode::Period) {
            projection2d.scale *= powf(0.25f32, time.delta_secs());
        }
    }

    if let Some(viewport) = camera.viewport.as_mut() {
        // Reset viewport size on window resize
        if viewport.physical_size.x > window_size.x || viewport.physical_size.y > window_size.y {
            viewport.physical_size = (window_size.as_vec2() * 0.75).as_uvec2();
        }

        // Viewport movement controls
        if input.pressed(KeyCode::KeyW) {
            viewport.physical_position.y = viewport.physical_position.y.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyS) {
            viewport.physical_position.y += uspeed;
        }
        if input.pressed(KeyCode::KeyA) {
            viewport.physical_position.x = viewport.physical_position.x.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyD) {
            viewport.physical_position.x += uspeed;
        }

        // Bound viewport position so it doesn't go off-screen
        viewport.physical_position = viewport
            .physical_position
            .min(window_size - viewport.physical_size);

        // Viewport size controls
        if input.pressed(KeyCode::KeyI) {
            viewport.physical_size.y = viewport.physical_size.y.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyK) {
            viewport.physical_size.y += uspeed;
        }
        if input.pressed(KeyCode::KeyJ) {
            viewport.physical_size.x = viewport.physical_size.x.saturating_sub(uspeed);
        }
        if input.pressed(KeyCode::KeyL) {
            viewport.physical_size.x += uspeed;
        }

        // Bound viewport size so it doesn't go off-screen
        viewport.physical_size = viewport
            .physical_size
            .min(window_size - viewport.physical_position)
            .max(UVec2::new(20, 20));
    }
}

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
    window: Single<&Window>,
) {
    let window_size = window.resolution.physical_size().as_vec2();

    // Initialize centered, non-window-filling viewport
    commands.spawn((
        Camera2d,
        Camera {
            viewport: Some(Viewport {
                physical_position: (window_size * 0.125).as_uvec2(),
                physical_size: (window_size * 0.75).as_uvec2(),
                ..default()
            }),
            ..default()
        },
    ));

    // Create a minimal UI explaining how to interact with the example
    commands.spawn((
        Text::new(
            "Move the mouse to see the circle follow your cursor.\n\
                    Use the arrow keys to move the camera.\n\
                    Use the comma and period keys to zoom in and out.\n\
                    Use the WASD keys to move the viewport.\n\
                    Use the IJKL keys to resize the viewport.",
        ),
        Node {
            position_type: PositionType::Absolute,
            top: px(12),
            left: px(12),
            ..default()
        },
    ));

    // Add mesh to make camera movement visible
    commands.spawn((
        Mesh2d(meshes.add(Rectangle::new(40.0, 20.0))),
        MeshMaterial2d(materials.add(Color::from(GREEN))),
    ));

    // Add background to visualize viewport bounds
    commands.spawn((
        Mesh2d(meshes.add(Rectangle::new(50000.0, 50000.0))),
        MeshMaterial2d(materials.add(Color::linear_rgb(0.01, 0.01, 0.01))),
        Transform::from_translation(Vec3::new(0.0, 0.0, -200.0)),
    ));
}

examples/testbed/2d.rs (line 507)

    pub fn setup(
        mut commands: Commands,
        mut textures: ResMut<Assets<Image>>,
        mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
    ) {
        commands.spawn((Camera2d, DespawnOnExit(super::Scene::TextureAtlasBuilder)));

        for (i, padding) in [UVec2::ZERO, PADDING_SIZE].into_iter().enumerate() {
            // generate solid red green and blue and yellow images
            let images = [
                [255, 0, 0, 255],
                [0, 255, 0, 255],
                [0, 0, 255, 255],
                [255, 255, 0, 255],
            ]
            .map(|pixel| {
                Image::new_fill(
                    Extent3d {
                        width: 28,
                        height: 28,
                        depth_or_array_layers: 1,
                    },
                    TextureDimension::D2,
                    &pixel,
                    TextureFormat::Rgba8UnormSrgb,
                    RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD,
                )
            });

            let mut texture_atlas_builder = TextureAtlasBuilder::default();
            texture_atlas_builder
                .initial_size(ATLAS_SIZE)
                .max_size(ATLAS_SIZE)
                .padding(padding);
            for image in &images {
                texture_atlas_builder.add_texture(None, image);
            }

            let (atlas_layout, _, atlas_texture) = texture_atlas_builder.build().expect(
                "The images are 28 pixels square, so they should fit with 4 pixels left over",
            );
            let atlas_layout = texture_atlases.add(atlas_layout);

            let mut nearest_atlas_image = atlas_texture.clone();
            nearest_atlas_image.sampler = ImageSampler::nearest();

            let atlas_handle = textures.add(atlas_texture);
            let nearest_atlas_handle = textures.add(nearest_atlas_image);

            let position = ((2. * i as f32 - 1.) * (0.625 * ATLAS_SIZE.x as f32 * ATLAS_SCALE))
                .round()
                * Vec3::X;

            commands.spawn((
                Sprite {
                    image: nearest_atlas_handle,
                    custom_size: Some(ATLAS_SIZE.as_vec2() * ATLAS_SCALE),
                    ..default()
                },
                Anchor::BOTTOM_CENTER,
                ShowAabbGizmo {
                    color: Some(Color::WHITE),
                },
                DespawnOnExit(super::Scene::TextureAtlasBuilder),
                Transform::from_translation(position),
            ));

            for (index, anchor) in [
                Anchor::BOTTOM_RIGHT,
                Anchor::BOTTOM_LEFT,
                Anchor::TOP_LEFT,
                Anchor::TOP_RIGHT,
            ]
            .into_iter()
            .enumerate()
            {
                commands.spawn((
                    Sprite {
                        image: atlas_handle.clone(),
                        texture_atlas: Some(TextureAtlas {
                            layout: atlas_layout.clone(),
                            index,
                        }),
                        custom_size: Some(IMAGE_SIZE.as_vec2() * IMAGE_SCALE),
                        ..default()
                    },
                    Transform::from_translation(
                        position
                            + -2.
                                * IMAGE_SCALE
                                * (Vec3::Y * IMAGE_SIZE.y as f32 + anchor.as_vec().extend(0.)),
                    ),
                    anchor,
                    DespawnOnExit(super::Scene::TextureAtlasBuilder),
                ));
            }
        }
    }

pub fn as_dvec2(self) -> DVec2

Casts all elements of self to f64.

pub fn as_i8vec2(self) -> I8Vec2

Casts all elements of self to i8.

pub fn as_u8vec2(self) -> U8Vec2

Casts all elements of self to u8.

pub fn as_i16vec2(self) -> I16Vec2

Casts all elements of self to i16.

pub fn as_u16vec2(self) -> U16Vec2

Casts all elements of self to u16.

pub fn as_ivec2(self) -> IVec2

Casts all elements of self to i32.

pub fn as_i64vec2(self) -> I64Vec2

Casts all elements of self to i64.

pub fn as_u64vec2(self) -> U64Vec2

Casts all elements of self to u64.

pub fn as_isizevec2(self) -> ISizeVec2

Casts all elements of self to isize.

pub fn as_usizevec2(self) -> USizeVec2

Casts all elements of self to usize.

pub const fn checked_add(self, rhs: UVec2) -> Option<UVec2>

Returns a vector containing the wrapping addition of self and rhs.

In other words this computes Some([self.x + rhs.x, self.y + rhs.y, ..]) but returns None on any overflow.

pub const fn checked_sub(self, rhs: UVec2) -> Option<UVec2>

Returns a vector containing the wrapping subtraction of self and rhs.

In other words this computes Some([self.x - rhs.x, self.y - rhs.y, ..]) but returns None on any overflow.

pub const fn checked_mul(self, rhs: UVec2) -> Option<UVec2>

Returns a vector containing the wrapping multiplication of self and rhs.

In other words this computes Some([self.x * rhs.x, self.y * rhs.y, ..]) but returns None on any overflow.

pub const fn checked_div(self, rhs: UVec2) -> Option<UVec2>

Returns a vector containing the wrapping division of self and rhs.

In other words this computes Some([self.x / rhs.x, self.y / rhs.y, ..]) but returns None on any division by zero.

pub const fn wrapping_add(self, rhs: UVec2) -> UVec2

Returns a vector containing the wrapping addition of self and rhs.

In other words this computes [self.x.wrapping_add(rhs.x), self.y.wrapping_add(rhs.y), ..].

pub const fn wrapping_sub(self, rhs: UVec2) -> UVec2

Returns a vector containing the wrapping subtraction of self and rhs.

In other words this computes [self.x.wrapping_sub(rhs.x), self.y.wrapping_sub(rhs.y), ..].

pub const fn wrapping_mul(self, rhs: UVec2) -> UVec2

Returns a vector containing the wrapping multiplication of self and rhs.

In other words this computes [self.x.wrapping_mul(rhs.x), self.y.wrapping_mul(rhs.y), ..].

pub const fn wrapping_div(self, rhs: UVec2) -> UVec2

Returns a vector containing the wrapping division of self and rhs.

In other words this computes [self.x.wrapping_div(rhs.x), self.y.wrapping_div(rhs.y), ..].

pub const fn saturating_add(self, rhs: UVec2) -> UVec2

Returns a vector containing the saturating addition of self and rhs.

In other words this computes [self.x.saturating_add(rhs.x), self.y.saturating_add(rhs.y), ..].

pub const fn saturating_sub(self, rhs: UVec2) -> UVec2

Returns a vector containing the saturating subtraction of self and rhs.

In other words this computes [self.x.saturating_sub(rhs.x), self.y.saturating_sub(rhs.y), ..].

pub const fn saturating_mul(self, rhs: UVec2) -> UVec2

Returns a vector containing the saturating multiplication of self and rhs.

In other words this computes [self.x.saturating_mul(rhs.x), self.y.saturating_mul(rhs.y), ..].

pub const fn saturating_div(self, rhs: UVec2) -> UVec2

Returns a vector containing the saturating division of self and rhs.

In other words this computes [self.x.saturating_div(rhs.x), self.y.saturating_div(rhs.y), ..].

pub const fn checked_add_signed(self, rhs: IVec2) -> Option<UVec2>

Returns a vector containing the wrapping addition of self and signed vector rhs.

In other words this computes Some([self.x + rhs.x, self.y + rhs.y, ..]) but returns None on any overflow.

pub const fn wrapping_add_signed(self, rhs: IVec2) -> UVec2

Returns a vector containing the wrapping addition of self and signed vector rhs.

In other words this computes [self.x.wrapping_add_signed(rhs.x), self.y.wrapping_add_signed(rhs.y), ..].

pub const fn saturating_add_signed(self, rhs: IVec2) -> UVec2

Returns a vector containing the saturating addition of self and signed vector rhs.

In other words this computes [self.x.saturating_add_signed(rhs.x), self.y.saturating_add_signed(rhs.y), ..].

Trait Implementations

impl Add for UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: UVec2) -> UVec2

Performs the + operation.

impl Add<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: &UVec2) -> UVec2

Performs the + operation.

impl Add<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: &UVec2) -> UVec2

Performs the + operation.

impl Add<&u32> for UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> UVec2

Performs the + operation.

impl Add<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> UVec2

Performs the + operation.

impl Add<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: UVec2) -> UVec2

Performs the + operation.

impl Add<u32> for UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> UVec2

Performs the + operation.

impl Add<u32> for &UVec2

type Output = UVec2

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> UVec2

Performs the + operation.

impl AddAssign for UVec2

fn add_assign(&mut self, rhs: UVec2)

Performs the += operation.

impl AddAssign<&UVec2> for UVec2

fn add_assign(&mut self, rhs: &UVec2)

Performs the += operation.

impl AddAssign<&u32> for UVec2

fn add_assign(&mut self, rhs: &u32)

Performs the += operation.

impl AddAssign<u32> for UVec2

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AsMut<[u32; 2]> for UVec2

fn as_mut(&mut self) -> &mut [u32; 2]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMutVectorParts<u32, 2> for UVec2

where UVec2: AsMut<[u32; 2]>, u32: VectorScalar,

fn as_mut_parts(&mut self) -> &mut [u32; 2]

impl AsRef<[u32; 2]> for UVec2

fn as_ref(&self) -> &[u32; 2]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRefVectorParts<u32, 2> for UVec2

where UVec2: AsRef<[u32; 2]>, u32: VectorScalar,

fn as_ref_parts(&self) -> &[u32; 2]

impl BitAnd for UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: UVec2) -> <UVec2 as BitAnd>::Output

Performs the & operation.

impl BitAnd<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: &UVec2) -> UVec2

Performs the & operation.

impl BitAnd<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: &UVec2) -> UVec2

Performs the & operation.

impl BitAnd<&u32> for UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: &u32) -> UVec2

Performs the & operation.

impl BitAnd<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: &u32) -> UVec2

Performs the & operation.

impl BitAnd<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: UVec2) -> UVec2

Performs the & operation.

impl BitAnd<u32> for UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> <UVec2 as BitAnd<u32>>::Output

Performs the & operation.

impl BitAnd<u32> for &UVec2

type Output = UVec2

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> UVec2

Performs the & operation.

impl BitAndAssign for UVec2

fn bitand_assign(&mut self, rhs: UVec2)

Performs the &= operation.

impl BitAndAssign<&UVec2> for UVec2

fn bitand_assign(&mut self, rhs: &UVec2)

Performs the &= operation.

impl BitAndAssign<&u32> for UVec2

fn bitand_assign(&mut self, rhs: &u32)

Performs the &= operation.

impl BitAndAssign<u32> for UVec2

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl BitOr for UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: UVec2) -> <UVec2 as BitOr>::Output

Performs the | operation.

impl BitOr<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: &UVec2) -> UVec2

Performs the | operation.

impl BitOr<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: &UVec2) -> UVec2

Performs the | operation.

impl BitOr<&u32> for UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: &u32) -> UVec2

Performs the | operation.

impl BitOr<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: &u32) -> UVec2

Performs the | operation.

impl BitOr<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: UVec2) -> UVec2

Performs the | operation.

impl BitOr<u32> for UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> <UVec2 as BitOr<u32>>::Output

Performs the | operation.

impl BitOr<u32> for &UVec2

type Output = UVec2

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> UVec2

Performs the | operation.

impl BitOrAssign for UVec2

fn bitor_assign(&mut self, rhs: UVec2)

Performs the |= operation.

impl BitOrAssign<&UVec2> for UVec2

fn bitor_assign(&mut self, rhs: &UVec2)

Performs the |= operation.

impl BitOrAssign<&u32> for UVec2

fn bitor_assign(&mut self, rhs: &u32)

Performs the |= operation.

impl BitOrAssign<u32> for UVec2

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl BitXor for UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: UVec2) -> <UVec2 as BitXor>::Output

Performs the ^ operation.

impl BitXor<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &UVec2) -> UVec2

Performs the ^ operation.

impl BitXor<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &UVec2) -> UVec2

Performs the ^ operation.

impl BitXor<&u32> for UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u32) -> UVec2

Performs the ^ operation.

impl BitXor<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u32) -> UVec2

Performs the ^ operation.

impl BitXor<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: UVec2) -> UVec2

Performs the ^ operation.

impl BitXor<u32> for UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> <UVec2 as BitXor<u32>>::Output

Performs the ^ operation.

impl BitXor<u32> for &UVec2

type Output = UVec2

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> UVec2

Performs the ^ operation.

impl BitXorAssign for UVec2

fn bitxor_assign(&mut self, rhs: UVec2)

Performs the ^= operation.

impl BitXorAssign<&UVec2> for UVec2

fn bitxor_assign(&mut self, rhs: &UVec2)

Performs the ^= operation.

impl BitXorAssign<&u32> for UVec2

fn bitxor_assign(&mut self, rhs: &u32)

Performs the ^= operation.

impl BitXorAssign<u32> for UVec2

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

impl Clone for UVec2

fn clone(&self) -> UVec2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for UVec2

impl CreateFrom for UVec2

where UVec2: FromVectorParts<u32, 2>, u32: VectorScalar + CreateFrom,

fn create_from<B>(reader: &mut Reader<B>) -> UVec2

where B: BufferRef,

impl Debug for UVec2

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

Formats the value using the given formatter.

impl Default for UVec2

fn default() -> UVec2

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for UVec2

Deserialize expects a sequence of 2 values.

fn deserialize<D>( deserializer: D, ) -> Result<UVec2, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for UVec2

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

Formats the value using the given formatter.

impl Div for UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: UVec2) -> UVec2

Performs the / operation.

impl Div<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: &UVec2) -> UVec2

Performs the / operation.

impl Div<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: &UVec2) -> UVec2

Performs the / operation.

impl Div<&u32> for UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> UVec2

Performs the / operation.

impl Div<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> UVec2

Performs the / operation.

impl Div<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: UVec2) -> UVec2

Performs the / operation.

impl Div<u32> for UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> UVec2

Performs the / operation.

impl Div<u32> for &UVec2

type Output = UVec2

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> UVec2

Performs the / operation.

impl DivAssign for UVec2

fn div_assign(&mut self, rhs: UVec2)

Performs the /= operation.

impl DivAssign<&UVec2> for UVec2

fn div_assign(&mut self, rhs: &UVec2)

Performs the /= operation.

impl DivAssign<&u32> for UVec2

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl DivAssign<u32> for UVec2

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl Eq for UVec2

impl From<(u32, u32)> for UVec2

fn from(t: (u32, u32)) -> UVec2

Converts to this type from the input type.

impl From<BVec2> for UVec2

fn from(v: BVec2) -> UVec2

Converts to this type from the input type.

impl From<U8Vec2> for UVec2

fn from(v: U8Vec2) -> UVec2

Converts to this type from the input type.

impl From<U16Vec2> for UVec2

fn from(v: U16Vec2) -> UVec2

Converts to this type from the input type.

impl From<UVec2> for DVec2

fn from(v: UVec2) -> DVec2

Converts to this type from the input type.

impl From<UVec2> for I64Vec2

fn from(v: UVec2) -> I64Vec2

Converts to this type from the input type.

impl From<UVec2> for U64Vec2

fn from(v: UVec2) -> U64Vec2

Converts to this type from the input type.

impl From<UVec2> for RenderTarget

fn from(value: UVec2) -> RenderTarget

Converts to this type from the input type.

impl From<UVec2> for WindowResolution

fn from(res: UVec2) -> WindowResolution

Converts to this type from the input type.

impl From<[u32; 2]> for UVec2

fn from(a: [u32; 2]) -> UVec2

Converts to this type from the input type.

impl FromArg for UVec2

type This<'from_arg> = UVec2

The type to convert into.

fn from_arg(arg: Arg<'_>) -> Result<<UVec2 as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromReflect for UVec2

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<UVec2>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl FromVectorParts<u32, 2> for UVec2

where UVec2: From<[u32; 2]>, u32: VectorScalar,

fn from_parts(parts: [u32; 2]) -> UVec2

impl GetOwnership for UVec2

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for UVec2

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Hash for UVec2

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for UVec2

type Output = u32

The returned type after indexing.

fn index(&self, index: usize) -> &<UVec2 as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for UVec2

fn index_mut(&mut self, index: usize) -> &mut <UVec2 as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl IntoReturn for UVec2

fn into_return<'into_return>(self) -> Return<'into_return>

where UVec2: 'into_return,

Converts Self into a Return value.

impl Mul for UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: UVec2) -> UVec2

Performs the * operation.

impl Mul<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: &UVec2) -> UVec2

Performs the * operation.

impl Mul<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: &UVec2) -> UVec2

Performs the * operation.

impl Mul<&u32> for UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> UVec2

Performs the * operation.

impl Mul<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> UVec2

Performs the * operation.

impl Mul<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: UVec2) -> UVec2

Performs the * operation.

impl Mul<u32> for UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> UVec2

Performs the * operation.

impl Mul<u32> for &UVec2

type Output = UVec2

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> UVec2

Performs the * operation.

impl MulAssign for UVec2

fn mul_assign(&mut self, rhs: UVec2)

Performs the *= operation.

impl MulAssign<&UVec2> for UVec2

fn mul_assign(&mut self, rhs: &UVec2)

Performs the *= operation.

impl MulAssign<&u32> for UVec2

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl MulAssign<u32> for UVec2

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl Not for UVec2

type Output = UVec2

The resulting type after applying the ! operator.

fn not(self) -> UVec2

Performs the unary ! operation.

impl Not for &UVec2

type Output = UVec2

The resulting type after applying the ! operator.

fn not(self) -> UVec2

Performs the unary ! operation.

impl PartialEq for UVec2

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

Equality operator ==.

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

Inequality operator !=.

impl PartialReflect for UVec2

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<UVec2>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<UVec2>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<UVec2>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Pod for UVec2

impl Product for UVec2

fn product<I>(iter: I) -> UVec2

where I: Iterator<Item = UVec2>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Product<&'a UVec2> for UVec2

fn product<I>(iter: I) -> UVec2

where I: Iterator<Item = &'a UVec2>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl ReadFrom for UVec2

where UVec2: AsMutVectorParts<u32, 2>, u32: VectorScalar + ReadFrom,

fn read_from<B>(&mut self, reader: &mut Reader<B>)

where B: BufferRef,

impl Reflect for UVec2

fn into_any(self: Box<UVec2>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<UVec2>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Rem for UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: UVec2) -> UVec2

Performs the % operation.

impl Rem<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: &UVec2) -> UVec2

Performs the % operation.

impl Rem<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: &UVec2) -> UVec2

Performs the % operation.

impl Rem<&u32> for UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> UVec2

Performs the % operation.

impl Rem<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> UVec2

Performs the % operation.

impl Rem<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: UVec2) -> UVec2

Performs the % operation.

impl Rem<u32> for UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> UVec2

Performs the % operation.

impl Rem<u32> for &UVec2

type Output = UVec2

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> UVec2

Performs the % operation.

impl RemAssign for UVec2

fn rem_assign(&mut self, rhs: UVec2)

Performs the %= operation.

impl RemAssign<&UVec2> for UVec2

fn rem_assign(&mut self, rhs: &UVec2)

Performs the %= operation.

impl RemAssign<&u32> for UVec2

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl RemAssign<u32> for UVec2

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl SampleUniform for UVec2

type Sampler = UniformVec2<UniformInt<u32>>

The UniformSampler implementation supporting type X.

impl Serialize for UVec2

Serialize as a sequence of 2 values.

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl ShaderSize for UVec2

where u32: ShaderSize,

const SHADER_SIZE: NonZero<u64> = _

Represents WGSL Size (equivalent to ShaderType::min_size)

impl ShaderType for UVec2

where u32: ShaderSize,

fn min_size() -> NonZero<u64>

Represents the minimum size of Self (equivalent to GPUBufferBindingLayout.minBindingSize)

fn size(&self) -> NonZero<u64>

Returns the size of Self at runtime

fn assert_uniform_compat()

Asserts that Self meets the requirements of the uniform address space restrictions on stored values and the uniform address space layout constraints

impl Shl for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> UVec2

Performs the << operation.

impl Shl<&IVec2> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &IVec2) -> UVec2

Performs the << operation.

impl Shl<&IVec2> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &IVec2) -> UVec2

Performs the << operation.

impl Shl<&UVec2> for I8Vec2

type Output = I8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> I8Vec2

Performs the << operation.

impl Shl<&UVec2> for &I8Vec2

type Output = I8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> I8Vec2

Performs the << operation.

impl Shl<&UVec2> for U8Vec2

type Output = U8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> U8Vec2

Performs the << operation.

impl Shl<&UVec2> for &U8Vec2

type Output = U8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> U8Vec2

Performs the << operation.

impl Shl<&UVec2> for I16Vec2

type Output = I16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> I16Vec2

Performs the << operation.

impl Shl<&UVec2> for &I16Vec2

type Output = I16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> I16Vec2

Performs the << operation.

impl Shl<&UVec2> for U16Vec2

type Output = U16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> U16Vec2

Performs the << operation.

impl Shl<&UVec2> for &U16Vec2

type Output = U16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> U16Vec2

Performs the << operation.

impl Shl<&UVec2> for IVec2

type Output = IVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> IVec2

Performs the << operation.

impl Shl<&UVec2> for &IVec2

type Output = IVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> IVec2

Performs the << operation.

impl Shl<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> UVec2

Performs the << operation.

impl Shl<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> UVec2

Performs the << operation.

impl Shl<&UVec2> for I64Vec2

type Output = I64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> I64Vec2

Performs the << operation.

impl Shl<&UVec2> for &I64Vec2

type Output = I64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> I64Vec2

Performs the << operation.

impl Shl<&UVec2> for U64Vec2

type Output = U64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> U64Vec2

Performs the << operation.

impl Shl<&UVec2> for &U64Vec2

type Output = U64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> U64Vec2

Performs the << operation.

impl Shl<&UVec2> for USizeVec2

type Output = USizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> USizeVec2

Performs the << operation.

impl Shl<&UVec2> for &USizeVec2

type Output = USizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> USizeVec2

Performs the << operation.

impl Shl<&UVec2> for ISizeVec2

type Output = ISizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> ISizeVec2

Performs the << operation.

impl Shl<&UVec2> for &ISizeVec2

type Output = ISizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &UVec2) -> ISizeVec2

Performs the << operation.

impl Shl<&i8> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> UVec2

Performs the << operation.

impl Shl<&i8> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> UVec2

Performs the << operation.

impl Shl<&i16> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> UVec2

Performs the << operation.

impl Shl<&i16> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> UVec2

Performs the << operation.

impl Shl<&i32> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> UVec2

Performs the << operation.

impl Shl<&i32> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> UVec2

Performs the << operation.

impl Shl<&i64> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> UVec2

Performs the << operation.

impl Shl<&i64> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> UVec2

Performs the << operation.

impl Shl<&u8> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> UVec2

Performs the << operation.

impl Shl<&u8> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> UVec2

Performs the << operation.

impl Shl<&u16> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> UVec2

Performs the << operation.

impl Shl<&u16> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> UVec2

Performs the << operation.

impl Shl<&u32> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> UVec2

Performs the << operation.

impl Shl<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> UVec2

Performs the << operation.

impl Shl<&u64> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> UVec2

Performs the << operation.

impl Shl<&u64> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> UVec2

Performs the << operation.

impl Shl<IVec2> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: IVec2) -> UVec2

Performs the << operation.

impl Shl<IVec2> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: IVec2) -> UVec2

Performs the << operation.

impl Shl<UVec2> for I8Vec2

type Output = I8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> I8Vec2

Performs the << operation.

impl Shl<UVec2> for &I8Vec2

type Output = I8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> I8Vec2

Performs the << operation.

impl Shl<UVec2> for U8Vec2

type Output = U8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> U8Vec2

Performs the << operation.

impl Shl<UVec2> for &U8Vec2

type Output = U8Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> U8Vec2

Performs the << operation.

impl Shl<UVec2> for I16Vec2

type Output = I16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> I16Vec2

Performs the << operation.

impl Shl<UVec2> for &I16Vec2

type Output = I16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> I16Vec2

Performs the << operation.

impl Shl<UVec2> for U16Vec2

type Output = U16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> U16Vec2

Performs the << operation.

impl Shl<UVec2> for &U16Vec2

type Output = U16Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> U16Vec2

Performs the << operation.

impl Shl<UVec2> for IVec2

type Output = IVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> IVec2

Performs the << operation.

impl Shl<UVec2> for &IVec2

type Output = IVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> IVec2

Performs the << operation.

impl Shl<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> UVec2

Performs the << operation.

impl Shl<UVec2> for I64Vec2

type Output = I64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> I64Vec2

Performs the << operation.

impl Shl<UVec2> for &I64Vec2

type Output = I64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> I64Vec2

Performs the << operation.

impl Shl<UVec2> for U64Vec2

type Output = U64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> U64Vec2

Performs the << operation.

impl Shl<UVec2> for &U64Vec2

type Output = U64Vec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> U64Vec2

Performs the << operation.

impl Shl<UVec2> for USizeVec2

type Output = USizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> USizeVec2

Performs the << operation.

impl Shl<UVec2> for &USizeVec2

type Output = USizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> USizeVec2

Performs the << operation.

impl Shl<UVec2> for ISizeVec2

type Output = ISizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> ISizeVec2

Performs the << operation.

impl Shl<UVec2> for &ISizeVec2

type Output = ISizeVec2

The resulting type after applying the << operator.

fn shl(self, rhs: UVec2) -> ISizeVec2

Performs the << operation.

impl Shl<i8> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> <UVec2 as Shl<i8>>::Output

Performs the << operation.

impl Shl<i8> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> UVec2

Performs the << operation.

impl Shl<i16> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> <UVec2 as Shl<i16>>::Output

Performs the << operation.

impl Shl<i16> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> UVec2

Performs the << operation.

impl Shl<i32> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> <UVec2 as Shl<i32>>::Output

Performs the << operation.

impl Shl<i32> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> UVec2

Performs the << operation.

impl Shl<i64> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> <UVec2 as Shl<i64>>::Output

Performs the << operation.

impl Shl<i64> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> UVec2

Performs the << operation.

impl Shl<u8> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> <UVec2 as Shl<u8>>::Output

Performs the << operation.

impl Shl<u8> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> UVec2

Performs the << operation.

impl Shl<u16> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> <UVec2 as Shl<u16>>::Output

Performs the << operation.

impl Shl<u16> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> UVec2

Performs the << operation.

impl Shl<u32> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> <UVec2 as Shl<u32>>::Output

Performs the << operation.

impl Shl<u32> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> UVec2

Performs the << operation.

impl Shl<u64> for UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> <UVec2 as Shl<u64>>::Output

Performs the << operation.

impl Shl<u64> for &UVec2

type Output = UVec2

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> UVec2

Performs the << operation.

impl ShlAssign<&i8> for UVec2

fn shl_assign(&mut self, rhs: &i8)

Performs the <<= operation.

impl ShlAssign<&i16> for UVec2

fn shl_assign(&mut self, rhs: &i16)

Performs the <<= operation.

impl ShlAssign<&i32> for UVec2

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl ShlAssign<&i64> for UVec2

fn shl_assign(&mut self, rhs: &i64)

Performs the <<= operation.

impl ShlAssign<&u8> for UVec2

fn shl_assign(&mut self, rhs: &u8)

Performs the <<= operation.

impl ShlAssign<&u16> for UVec2

fn shl_assign(&mut self, rhs: &u16)

Performs the <<= operation.

impl ShlAssign<&u32> for UVec2

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl ShlAssign<&u64> for UVec2

fn shl_assign(&mut self, rhs: &u64)

Performs the <<= operation.

impl ShlAssign<i8> for UVec2

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl ShlAssign<i16> for UVec2

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl ShlAssign<i32> for UVec2

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl ShlAssign<i64> for UVec2

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl ShlAssign<u8> for UVec2

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl ShlAssign<u16> for UVec2

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl ShlAssign<u32> for UVec2

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl ShlAssign<u64> for UVec2

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl Shr for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> UVec2

Performs the >> operation.

impl Shr<&IVec2> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &IVec2) -> UVec2

Performs the >> operation.

impl Shr<&IVec2> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &IVec2) -> UVec2

Performs the >> operation.

impl Shr<&UVec2> for I8Vec2

type Output = I8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> I8Vec2

Performs the >> operation.

impl Shr<&UVec2> for &I8Vec2

type Output = I8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> I8Vec2

Performs the >> operation.

impl Shr<&UVec2> for U8Vec2

type Output = U8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> U8Vec2

Performs the >> operation.

impl Shr<&UVec2> for &U8Vec2

type Output = U8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> U8Vec2

Performs the >> operation.

impl Shr<&UVec2> for I16Vec2

type Output = I16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> I16Vec2

Performs the >> operation.

impl Shr<&UVec2> for &I16Vec2

type Output = I16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> I16Vec2

Performs the >> operation.

impl Shr<&UVec2> for U16Vec2

type Output = U16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> U16Vec2

Performs the >> operation.

impl Shr<&UVec2> for &U16Vec2

type Output = U16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> U16Vec2

Performs the >> operation.

impl Shr<&UVec2> for IVec2

type Output = IVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> IVec2

Performs the >> operation.

impl Shr<&UVec2> for &IVec2

type Output = IVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> IVec2

Performs the >> operation.

impl Shr<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> UVec2

Performs the >> operation.

impl Shr<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> UVec2

Performs the >> operation.

impl Shr<&UVec2> for I64Vec2

type Output = I64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> I64Vec2

Performs the >> operation.

impl Shr<&UVec2> for &I64Vec2

type Output = I64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> I64Vec2

Performs the >> operation.

impl Shr<&UVec2> for U64Vec2

type Output = U64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> U64Vec2

Performs the >> operation.

impl Shr<&UVec2> for &U64Vec2

type Output = U64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> U64Vec2

Performs the >> operation.

impl Shr<&UVec2> for USizeVec2

type Output = USizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> USizeVec2

Performs the >> operation.

impl Shr<&UVec2> for &USizeVec2

type Output = USizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> USizeVec2

Performs the >> operation.

impl Shr<&UVec2> for ISizeVec2

type Output = ISizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> ISizeVec2

Performs the >> operation.

impl Shr<&UVec2> for &ISizeVec2

type Output = ISizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &UVec2) -> ISizeVec2

Performs the >> operation.

impl Shr<&i8> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> UVec2

Performs the >> operation.

impl Shr<&i8> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> UVec2

Performs the >> operation.

impl Shr<&i16> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> UVec2

Performs the >> operation.

impl Shr<&i16> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> UVec2

Performs the >> operation.

impl Shr<&i32> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> UVec2

Performs the >> operation.

impl Shr<&i32> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> UVec2

Performs the >> operation.

impl Shr<&i64> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> UVec2

Performs the >> operation.

impl Shr<&i64> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> UVec2

Performs the >> operation.

impl Shr<&u8> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> UVec2

Performs the >> operation.

impl Shr<&u8> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> UVec2

Performs the >> operation.

impl Shr<&u16> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> UVec2

Performs the >> operation.

impl Shr<&u16> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> UVec2

Performs the >> operation.

impl Shr<&u32> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> UVec2

Performs the >> operation.

impl Shr<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> UVec2

Performs the >> operation.

impl Shr<&u64> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> UVec2

Performs the >> operation.

impl Shr<&u64> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> UVec2

Performs the >> operation.

impl Shr<IVec2> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: IVec2) -> UVec2

Performs the >> operation.

impl Shr<IVec2> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: IVec2) -> UVec2

Performs the >> operation.

impl Shr<UVec2> for I8Vec2

type Output = I8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> I8Vec2

Performs the >> operation.

impl Shr<UVec2> for &I8Vec2

type Output = I8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> I8Vec2

Performs the >> operation.

impl Shr<UVec2> for U8Vec2

type Output = U8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> U8Vec2

Performs the >> operation.

impl Shr<UVec2> for &U8Vec2

type Output = U8Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> U8Vec2

Performs the >> operation.

impl Shr<UVec2> for I16Vec2

type Output = I16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> I16Vec2

Performs the >> operation.

impl Shr<UVec2> for &I16Vec2

type Output = I16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> I16Vec2

Performs the >> operation.

impl Shr<UVec2> for U16Vec2

type Output = U16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> U16Vec2

Performs the >> operation.

impl Shr<UVec2> for &U16Vec2

type Output = U16Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> U16Vec2

Performs the >> operation.

impl Shr<UVec2> for IVec2

type Output = IVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> IVec2

Performs the >> operation.

impl Shr<UVec2> for &IVec2

type Output = IVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> IVec2

Performs the >> operation.

impl Shr<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> UVec2

Performs the >> operation.

impl Shr<UVec2> for I64Vec2

type Output = I64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> I64Vec2

Performs the >> operation.

impl Shr<UVec2> for &I64Vec2

type Output = I64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> I64Vec2

Performs the >> operation.

impl Shr<UVec2> for U64Vec2

type Output = U64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> U64Vec2

Performs the >> operation.

impl Shr<UVec2> for &U64Vec2

type Output = U64Vec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> U64Vec2

Performs the >> operation.

impl Shr<UVec2> for USizeVec2

type Output = USizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> USizeVec2

Performs the >> operation.

impl Shr<UVec2> for &USizeVec2

type Output = USizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> USizeVec2

Performs the >> operation.

impl Shr<UVec2> for ISizeVec2

type Output = ISizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> ISizeVec2

Performs the >> operation.

impl Shr<UVec2> for &ISizeVec2

type Output = ISizeVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: UVec2) -> ISizeVec2

Performs the >> operation.

impl Shr<i8> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> <UVec2 as Shr<i8>>::Output

Performs the >> operation.

impl Shr<i8> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> UVec2

Performs the >> operation.

impl Shr<i16> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> <UVec2 as Shr<i16>>::Output

Performs the >> operation.

impl Shr<i16> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> UVec2

Performs the >> operation.

impl Shr<i32> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> <UVec2 as Shr<i32>>::Output

Performs the >> operation.

impl Shr<i32> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> UVec2

Performs the >> operation.

impl Shr<i64> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> <UVec2 as Shr<i64>>::Output

Performs the >> operation.

impl Shr<i64> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> UVec2

Performs the >> operation.

impl Shr<u8> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> <UVec2 as Shr<u8>>::Output

Performs the >> operation.

impl Shr<u8> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> UVec2

Performs the >> operation.

impl Shr<u16> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> <UVec2 as Shr<u16>>::Output

Performs the >> operation.

impl Shr<u16> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> UVec2

Performs the >> operation.

impl Shr<u32> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> <UVec2 as Shr<u32>>::Output

Performs the >> operation.

impl Shr<u32> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> UVec2

Performs the >> operation.

impl Shr<u64> for UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> <UVec2 as Shr<u64>>::Output

Performs the >> operation.

impl Shr<u64> for &UVec2

type Output = UVec2

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> UVec2

Performs the >> operation.

impl ShrAssign<&i8> for UVec2

fn shr_assign(&mut self, rhs: &i8)

Performs the >>= operation.

impl ShrAssign<&i16> for UVec2

fn shr_assign(&mut self, rhs: &i16)

Performs the >>= operation.

impl ShrAssign<&i32> for UVec2

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl ShrAssign<&i64> for UVec2

fn shr_assign(&mut self, rhs: &i64)

Performs the >>= operation.

impl ShrAssign<&u8> for UVec2

fn shr_assign(&mut self, rhs: &u8)

Performs the >>= operation.

impl ShrAssign<&u16> for UVec2

fn shr_assign(&mut self, rhs: &u16)

Performs the >>= operation.

impl ShrAssign<&u32> for UVec2

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl ShrAssign<&u64> for UVec2

fn shr_assign(&mut self, rhs: &u64)

Performs the >>= operation.

impl ShrAssign<i8> for UVec2

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl ShrAssign<i16> for UVec2

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl ShrAssign<i32> for UVec2

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl ShrAssign<i64> for UVec2

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl ShrAssign<u8> for UVec2

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl ShrAssign<u16> for UVec2

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl ShrAssign<u32> for UVec2

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl ShrAssign<u64> for UVec2

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl Struct for UVec2

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl StructuralPartialEq for UVec2

impl Sub for UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: UVec2) -> UVec2

Performs the - operation.

impl Sub<&UVec2> for UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: &UVec2) -> UVec2

Performs the - operation.

impl Sub<&UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: &UVec2) -> UVec2

Performs the - operation.

impl Sub<&u32> for UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> UVec2

Performs the - operation.

impl Sub<&u32> for &UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> UVec2

Performs the - operation.

impl Sub<UVec2> for &UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: UVec2) -> UVec2

Performs the - operation.

impl Sub<u32> for UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> UVec2

Performs the - operation.

impl Sub<u32> for &UVec2

type Output = UVec2

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> UVec2

Performs the - operation.

impl SubAssign for UVec2

fn sub_assign(&mut self, rhs: UVec2)

Performs the -= operation.

impl SubAssign<&UVec2> for UVec2

fn sub_assign(&mut self, rhs: &UVec2)

Performs the -= operation.

impl SubAssign<&u32> for UVec2

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl SubAssign<u32> for UVec2

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl Sum for UVec2

fn sum<I>(iter: I) -> UVec2

where I: Iterator<Item = UVec2>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a> Sum<&'a UVec2> for UVec2

fn sum<I>(iter: I) -> UVec2

where I: Iterator<Item = &'a UVec2>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl ToExtents for UVec2

fn to_extents(self) -> Extent3d

Converts this type to an Extent3d.

impl TryFrom<I8Vec2> for UVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: I8Vec2) -> Result<UVec2, <UVec2 as TryFrom<I8Vec2>>::Error>

Performs the conversion.

impl TryFrom<I16Vec2> for UVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: I16Vec2) -> Result<UVec2, <UVec2 as TryFrom<I16Vec2>>::Error>

Performs the conversion.

impl TryFrom<I64Vec2> for UVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: I64Vec2) -> Result<UVec2, <UVec2 as TryFrom<I64Vec2>>::Error>

Performs the conversion.

impl TryFrom<ISizeVec2> for UVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: ISizeVec2) -> Result<UVec2, <UVec2 as TryFrom<ISizeVec2>>::Error>

Performs the conversion.

impl TryFrom<IVec2> for UVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: IVec2) -> Result<UVec2, <UVec2 as TryFrom<IVec2>>::Error>

Performs the conversion.

impl TryFrom<U64Vec2> for UVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: U64Vec2) -> Result<UVec2, <UVec2 as TryFrom<U64Vec2>>::Error>

Performs the conversion.

impl TryFrom<USizeVec2> for UVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: USizeVec2) -> Result<UVec2, <UVec2 as TryFrom<USizeVec2>>::Error>

Performs the conversion.

impl TryFrom<UVec2> for I8Vec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: UVec2) -> Result<I8Vec2, <I8Vec2 as TryFrom<UVec2>>::Error>

Performs the conversion.

impl TryFrom<UVec2> for U8Vec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: UVec2) -> Result<U8Vec2, <U8Vec2 as TryFrom<UVec2>>::Error>

Performs the conversion.

impl TryFrom<UVec2> for I16Vec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: UVec2) -> Result<I16Vec2, <I16Vec2 as TryFrom<UVec2>>::Error>

Performs the conversion.

impl TryFrom<UVec2> for U16Vec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: UVec2) -> Result<U16Vec2, <U16Vec2 as TryFrom<UVec2>>::Error>

Performs the conversion.

impl TryFrom<UVec2> for IVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: UVec2) -> Result<IVec2, <IVec2 as TryFrom<UVec2>>::Error>

Performs the conversion.

impl TryFrom<UVec2> for USizeVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: UVec2) -> Result<USizeVec2, <USizeVec2 as TryFrom<UVec2>>::Error>

Performs the conversion.

impl TryFrom<UVec2> for ISizeVec2

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(v: UVec2) -> Result<ISizeVec2, <ISizeVec2 as TryFrom<UVec2>>::Error>

Performs the conversion.

impl TypePath for UVec2

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for UVec2

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Vec2Swizzles for UVec2

type Vec3 = UVec3

type Vec4 = UVec4

fn xx(self) -> UVec2

fn yx(self) -> UVec2

fn yy(self) -> UVec2

fn xxx(self) -> UVec3

fn xxy(self) -> UVec3

fn xyx(self) -> UVec3

fn xyy(self) -> UVec3

fn yxx(self) -> UVec3

fn yxy(self) -> UVec3

fn yyx(self) -> UVec3

fn yyy(self) -> UVec3

fn xxxx(self) -> UVec4

fn xxxy(self) -> UVec4

fn xxyx(self) -> UVec4

fn xxyy(self) -> UVec4

fn xyxx(self) -> UVec4

fn xyxy(self) -> UVec4

fn xyyx(self) -> UVec4

fn xyyy(self) -> UVec4

fn yxxx(self) -> UVec4

fn yxxy(self) -> UVec4

fn yxyx(self) -> UVec4

fn yxyy(self) -> UVec4

fn yyxx(self) -> UVec4

fn yyxy(self) -> UVec4

fn yyyx(self) -> UVec4

fn yyyy(self) -> UVec4

fn xy(self) -> Self

impl WriteInto for UVec2

where UVec2: AsRefVectorParts<u32, 2>, u32: VectorScalar + WriteInto,

fn write_into<B>(&self, writer: &mut Writer<B>)

where B: BufferMut,

impl Zeroable for UVec2

fn zeroed() -> Self

Calls zeroed.