Enum ImageSampler 

pub enum ImageSampler {
    Default,
    Descriptor(ImageSamplerDescriptor),
}

Available on crate feature bevy_image only.

Used in Image, this determines what image sampler to use when rendering. The default setting, ImageSampler::Default, will read the sampler from the ImagePlugin at setup. Setting this to ImageSampler::Descriptor will override the global default descriptor for this Image.

Variants

Default

Default image sampler, derived from the ImagePlugin setup.

Descriptor(ImageSamplerDescriptor)

Custom sampler for this image which will override global default.

Implementations

impl ImageSampler

pub fn linear() -> ImageSampler

Returns an image sampler with ImageFilterMode::Linear min and mag filters

Examples found in repository

examples/2d/texture_atlas.rs (line 65)

fn setup(
    mut commands: Commands,
    rpg_sprite_handles: Res<RpgSpriteFolder>,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
    loaded_folders: Res<Assets<LoadedFolder>>,
    mut textures: ResMut<Assets<Image>>,
) {
    let loaded_folder = loaded_folders.get(&rpg_sprite_handles.0).unwrap();

    // Create texture atlases with different padding and sampling

    let (texture_atlas_linear, linear_sources, linear_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::linear()),
        &mut textures,
    );
    let atlas_linear_handle = texture_atlases.add(texture_atlas_linear);

    let (texture_atlas_nearest, nearest_sources, nearest_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::nearest()),
        &mut textures,
    );
    let atlas_nearest_handle = texture_atlases.add(texture_atlas_nearest);

    let (texture_atlas_linear_padded, linear_padded_sources, linear_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::linear()),
            &mut textures,
        );
    let atlas_linear_padded_handle = texture_atlases.add(texture_atlas_linear_padded.clone());

    let (texture_atlas_nearest_padded, nearest_padded_sources, nearest_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::nearest()),
            &mut textures,
        );
    let atlas_nearest_padded_handle = texture_atlases.add(texture_atlas_nearest_padded);

    commands.spawn(Camera2d);

    // Padded textures are to the right, unpadded to the left

    // Draw unpadded texture atlas
    commands.spawn((
        Sprite::from_image(linear_texture.clone()),
        Transform {
            translation: Vec3::new(-250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));

    // Draw padded texture atlas
    commands.spawn((
        Sprite::from_image(linear_padded_texture.clone()),
        Transform {
            translation: Vec3::new(250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));

    let font = asset_server.load("fonts/FiraSans-Bold.ttf");

    // Padding label text style
    let text_style: TextFont = TextFont {
        font: font.clone().into(),
        font_size: FontSize::Px(42.0),
        ..default()
    };

    // Labels to indicate padding

    // No padding
    create_label(
        &mut commands,
        (-250.0, 250.0, 0.0),
        "No padding",
        text_style.clone(),
    );

    // Padding
    create_label(&mut commands, (250.0, 250.0, 0.0), "Padding", text_style);

    // Get handle to a sprite to render
    let vendor_handle: Handle<Image> = asset_server
        .get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png")
        .unwrap();

    // Configuration array to render sprites through iteration
    let configurations: [(
        &str,
        Handle<TextureAtlasLayout>,
        TextureAtlasSources,
        Handle<Image>,
        f32,
    ); 4] = [
        (
            "Linear",
            atlas_linear_handle,
            linear_sources,
            linear_texture,
            -350.0,
        ),
        (
            "Nearest",
            atlas_nearest_handle,
            nearest_sources,
            nearest_texture,
            -150.0,
        ),
        (
            "Linear",
            atlas_linear_padded_handle,
            linear_padded_sources,
            linear_padded_texture,
            150.0,
        ),
        (
            "Nearest",
            atlas_nearest_padded_handle,
            nearest_padded_sources,
            nearest_padded_texture,
            350.0,
        ),
    ];

    // Label text style
    let sampling_label_style = TextFont {
        font: font.into(),
        font_size: FontSize::Px(25.0),
        ..default()
    };

    let base_y = 80.0; // y position of the sprites

    for (sampling, atlas_handle, atlas_sources, atlas_texture, x) in configurations {
        // Render a sprite from the texture_atlas
        create_sprite_from_atlas(
            &mut commands,
            (x, base_y, 0.0),
            atlas_texture,
            atlas_sources,
            atlas_handle,
            &vendor_handle,
        );

        // Render a label to indicate the sampling setting
        create_label(
            &mut commands,
            (x, base_y + 110.0, 0.0), // Offset to y position of the sprite
            sampling,
            sampling_label_style.clone(),
        );
    }
}

pub fn nearest() -> ImageSampler

Returns an image sampler with ImageFilterMode::Nearest min and mag filters

Examples found in repository

examples/ui/images/ui_texture_slice_flip_and_tile.rs (line 22)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    let image = asset_server
        .load_builder()
        .with_settings(|settings: &mut ImageLoaderSettings| {
            // Need to use nearest filtering to avoid bleeding between the slices with tiling
            settings.sampler = ImageSampler::nearest();
        })
        .load("textures/fantasy_ui_borders/numbered_slices.png");

    let slicer = TextureSlicer {
        // `numbered_slices.png` is 48 pixels square. `BorderRect::square(16.)` insets the slicing line from each edge by 16 pixels, resulting in nine slices that are each 16 pixels square.
        border: BorderRect::all(16.),
        // With `SliceScaleMode::Tile` the side and center slices are tiled to fill the side and center sections of the target.
        // And with a `stretch_value` of `1.` the tiles will have the same size as the corresponding slices in the source image.
        center_scale_mode: SliceScaleMode::Tile { stretch_value: 1. },
        sides_scale_mode: SliceScaleMode::Tile { stretch_value: 1. },
        ..default()
    };

    // ui camera
    commands.spawn(Camera2d);

    commands
        .spawn(Node {
            width: percent(100),
            height: percent(100),
            justify_content: JustifyContent::Center,
            align_content: AlignContent::Center,
            flex_wrap: FlexWrap::Wrap,
            column_gap: px(10),
            row_gap: px(10),
            ..default()
        })
        .with_children(|parent| {
            for [columns, rows] in [[3, 3], [4, 4], [5, 4], [4, 5], [5, 5]] {
                for (flip_x, flip_y) in [(false, false), (false, true), (true, false), (true, true)]
                {
                    parent.spawn((
                        ImageNode {
                            image: image.clone(),
                            flip_x,
                            flip_y,
                            image_mode: NodeImageMode::Sliced(slicer.clone()),
                            ..default()
                        },
                        Node {
                            width: px(16 * columns),
                            height: px(16 * rows),
                            ..default()
                        },
                    ));
                }
            }
        });
}

examples/asset/asset_saving.rs (line 110)

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut images: ResMut<Assets<Image>>,
) {
    commands.spawn((
        Camera2d,
        Projection::Orthographic(OrthographicProjection {
            scaling_mode: ScalingMode::FixedVertical {
                viewport_height: 125.0,
            },
            ..OrthographicProjection::default_2d()
        }),
    ));

    commands.spawn(Text(
        r"Select a color from the palette at the bottom
LMB - Draw with selected color
F5 - Save image"
            .into(),
    ));

    let handle = asset_server
        .load_builder()
        .with_settings(|settings: &mut ImageLoaderSettings| {
            settings.sampler = ImageSampler::nearest();
        })
        .load(ASSET_PATH);
    commands.spawn((
        Sprite {
            image: handle.clone(),
            ..Default::default()
        },
        SpriteToSave,
        Pickable::default(),
    ));

    // We're doing something a little cursed here: we initiate a load, and then insert a default
    // image into that handle. If the load succeeds, the image will be replaced with the loaded
    // contents. If it fails, the default image will remain. In real code, you likely want to poll
    // `AssetServer::load_state` and only insert this on load failure.
    images
        .insert(&handle, {
            let mut image = Image::new_fill(
                Extent3d {
                    width: 100,
                    height: 100,
                    depth_or_array_layers: 1,
                },
                TextureDimension::D2,
                &[0, 0, 0, 255],
                TextureFormat::Rgba8Unorm,
                RenderAssetUsages::all(),
            );
            image.sampler = ImageSampler::nearest();
            image
        })
        .unwrap();

    commands.insert_resource(ImageToSave(handle));

    let container = commands
        .spawn((
            Node {
                width: percent(100),
                height: percent(100),
                align_items: AlignItems::End,
                justify_content: JustifyContent::Center,
                ..Default::default()
            },
            Pickable::IGNORE,
        ))
        .id();

    for color in [
        Color::WHITE,
        Color::Srgba(tailwind::RED_500),
        Color::Srgba(tailwind::ORANGE_500),
        Color::Srgba(tailwind::YELLOW_500),
        Color::Srgba(tailwind::GREEN_500),
        Color::Srgba(tailwind::BLUE_500),
        Color::Srgba(tailwind::INDIGO_500),
        Color::Srgba(tailwind::VIOLET_500),
        Color::BLACK,
    ] {
        let mut entity = commands.spawn((
            Node {
                width: vw(5),
                height: vh(5),
                border: px(5).all(),
                ..Default::default()
            },
            SelectableColor,
            BackgroundColor(color),
            BorderColor::all(NORMAL_COLOR),
            ChildOf(container),
        ));
        if color == Color::WHITE {
            entity.insert((Selected, BorderColor::all(SELECTED_COLOR)));
        }
    }
}

examples/asset/asset_settings.rs (line 68)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    // Without any .meta file specifying settings, the default sampler [ImagePlugin::default()] is used for loading images.
    // If you are using a very small image and rendering it larger like seen here, the default linear filtering will result in a blurry image.
    // Useful note: The default sampler specified by the ImagePlugin is *not* the same as the default implementation of sampler. This is why
    // everything uses linear by default but if you look at the default of sampler, it uses nearest.
    commands.spawn((
        Sprite {
            image: asset_server.load("bevy_pixel_dark.png"),
            custom_size: Some(Vec2 { x: 160.0, y: 120.0 }),
            ..Default::default()
        },
        Transform::from_xyz(-100.0, 0.0, 0.0),
    ));

    // When a .meta file is added with the same name as the asset and a '.meta' extension
    // you can (and must) specify all fields of the asset loader's settings for that
    // particular asset, in this case [ImageLoaderSettings]. Take a look at
    // examples/asset/files/bevy_pixel_dark_with_meta.png.meta
    // for the format and you'll notice, the only non-default option is setting Nearest
    // filtering. This tends to work much better for pixel art assets.
    // A good reference when filling this out is to check out [ImageLoaderSettings::default()]
    // and follow to the default implementation of each fields type.
    // https://docs.rs/bevy/latest/bevy/image/struct.ImageLoaderSettings.html
    commands.spawn((
        Sprite {
            image: asset_server.load("bevy_pixel_dark_with_meta.png"),
            custom_size: Some(Vec2 { x: 160.0, y: 120.0 }),
            ..Default::default()
        },
        Transform::from_xyz(100.0, 0.0, 0.0),
    ));

    // Another option is to use the LoadBuilder::with_settings function.
    // With this you can specify the same settings upon loading your asset with a
    // couple of differences. A big one is that you aren't required to set *every*
    // setting, just modify the ones that you need. It works by passing in a function
    // (in this case an anonymous closure) that takes a reference to the settings type
    // that is then modified in the function.
    // Do note that if you want to load the same asset with different settings, the
    // settings changes from any loads after the first of the same asset will be ignored.
    // This is why this one loads a differently named copy of the asset instead of using
    // same one as without a .meta file.
    commands.spawn((
        Sprite {
            image: asset_server
                .load_builder()
                .with_settings(|settings: &mut ImageLoaderSettings| {
                    settings.sampler = ImageSampler::nearest();
                })
                .load("bevy_pixel_dark_with_settings.png"),
            custom_size: Some(Vec2 { x: 160.0, y: 120.0 }),
            ..Default::default()
        },
        Transform::from_xyz(0.0, 150.0, 0.0),
    ));

    commands.spawn(Camera2d);
}

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

    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),
                ));
            }
        }
    }

examples/2d/texture_atlas.rs (line 73)

fn setup(
    mut commands: Commands,
    rpg_sprite_handles: Res<RpgSpriteFolder>,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
    loaded_folders: Res<Assets<LoadedFolder>>,
    mut textures: ResMut<Assets<Image>>,
) {
    let loaded_folder = loaded_folders.get(&rpg_sprite_handles.0).unwrap();

    // Create texture atlases with different padding and sampling

    let (texture_atlas_linear, linear_sources, linear_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::linear()),
        &mut textures,
    );
    let atlas_linear_handle = texture_atlases.add(texture_atlas_linear);

    let (texture_atlas_nearest, nearest_sources, nearest_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::nearest()),
        &mut textures,
    );
    let atlas_nearest_handle = texture_atlases.add(texture_atlas_nearest);

    let (texture_atlas_linear_padded, linear_padded_sources, linear_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::linear()),
            &mut textures,
        );
    let atlas_linear_padded_handle = texture_atlases.add(texture_atlas_linear_padded.clone());

    let (texture_atlas_nearest_padded, nearest_padded_sources, nearest_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::nearest()),
            &mut textures,
        );
    let atlas_nearest_padded_handle = texture_atlases.add(texture_atlas_nearest_padded);

    commands.spawn(Camera2d);

    // Padded textures are to the right, unpadded to the left

    // Draw unpadded texture atlas
    commands.spawn((
        Sprite::from_image(linear_texture.clone()),
        Transform {
            translation: Vec3::new(-250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));

    // Draw padded texture atlas
    commands.spawn((
        Sprite::from_image(linear_padded_texture.clone()),
        Transform {
            translation: Vec3::new(250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));

    let font = asset_server.load("fonts/FiraSans-Bold.ttf");

    // Padding label text style
    let text_style: TextFont = TextFont {
        font: font.clone().into(),
        font_size: FontSize::Px(42.0),
        ..default()
    };

    // Labels to indicate padding

    // No padding
    create_label(
        &mut commands,
        (-250.0, 250.0, 0.0),
        "No padding",
        text_style.clone(),
    );

    // Padding
    create_label(&mut commands, (250.0, 250.0, 0.0), "Padding", text_style);

    // Get handle to a sprite to render
    let vendor_handle: Handle<Image> = asset_server
        .get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png")
        .unwrap();

    // Configuration array to render sprites through iteration
    let configurations: [(
        &str,
        Handle<TextureAtlasLayout>,
        TextureAtlasSources,
        Handle<Image>,
        f32,
    ); 4] = [
        (
            "Linear",
            atlas_linear_handle,
            linear_sources,
            linear_texture,
            -350.0,
        ),
        (
            "Nearest",
            atlas_nearest_handle,
            nearest_sources,
            nearest_texture,
            -150.0,
        ),
        (
            "Linear",
            atlas_linear_padded_handle,
            linear_padded_sources,
            linear_padded_texture,
            150.0,
        ),
        (
            "Nearest",
            atlas_nearest_padded_handle,
            nearest_padded_sources,
            nearest_padded_texture,
            350.0,
        ),
    ];

    // Label text style
    let sampling_label_style = TextFont {
        font: font.into(),
        font_size: FontSize::Px(25.0),
        ..default()
    };

    let base_y = 80.0; // y position of the sprites

    for (sampling, atlas_handle, atlas_sources, atlas_texture, x) in configurations {
        // Render a sprite from the texture_atlas
        create_sprite_from_atlas(
            &mut commands,
            (x, base_y, 0.0),
            atlas_texture,
            atlas_sources,
            atlas_handle,
            &vendor_handle,
        );

        // Render a label to indicate the sampling setting
        create_label(
            &mut commands,
            (x, base_y + 110.0, 0.0), // Offset to y position of the sprite
            sampling,
            sampling_label_style.clone(),
        );
    }
}

pub fn get_or_init_descriptor(&mut self) -> &mut ImageSamplerDescriptor

Initialize the descriptor if it is not already initialized.

Descriptor is typically initialized by Bevy when the image is loaded, so this is convenient shortcut for updating the descriptor.

Examples found in repository

tests/3d/test_meshlet.rs (line 220)

fn mipmap_material(
    standard_materials: &mut Assets<StandardMaterial>,
    images: &mut Assets<Image>,
) -> Handle<StandardMaterial> {
    let mip_colors = [
        Srgba::rgb(1.0, 0.0, 0.0),
        Srgba::rgb(0.0, 1.0, 0.0),
        Srgba::rgb(0.0, 0.0, 1.0),
        Srgba::rgb(1.0, 1.0, 0.0),
        Srgba::rgb(0.0, 1.0, 1.0),
        Srgba::rgb(1.0, 0.0, 1.0),
    ];

    let size = 256;

    let mut image = Image::new_uninit(
        Extent3d {
            width: size as u32,
            height: size as u32,
            depth_or_array_layers: 1,
        },
        TextureDimension::D2,
        TextureFormat::Rgba8UnormSrgb,
        RenderAssetUsages::default(),
    );

    image.texture_descriptor.mip_level_count = mip_colors.len() as u32;

    image
        .sampler
        .get_or_init_descriptor()
        .set_filter(ImageFilterMode::Linear)
        .set_address_mode(ImageAddressMode::Repeat);

    image.data = Some(
        mip_colors
            .iter()
            .enumerate()
            .flat_map(|(level, color)| checkerboard(size / 2_usize.pow(level as u32), *color))
            .collect(),
    );

    standard_materials.add(StandardMaterial {
        base_color_texture: Some(images.add(image)),
        perceptual_roughness: 1.0,
        ..default()
    })
}

examples/3d/solari_reflections.rs (line 322)

fn spawn_room(
    commands: &mut Commands,
    asset_server: &AssetServer,
    meshes: &mut Assets<Mesh>,
    materials: &mut Assets<StandardMaterial>,
) {
    let mut floor_mesh = raytraced(Plane3d::new(Vec3::Y, Vec2::new(9.0, 10.5)));
    match floor_mesh.attribute_mut(Mesh::ATTRIBUTE_UV_0).unwrap() {
        VertexAttributeValues::Float32x2(items) => {
            items.iter_mut().flatten().for_each(|x| *x *= 9.0);
        }
        _ => unreachable!(),
    }
    let floor = meshes.add(floor_mesh);
    commands.spawn((
        RaytracingMesh3d(floor.clone()),
        Mesh3d(floor),
        MeshMaterial3d(
            materials.add(StandardMaterial {
                base_color_texture: Some(
                    asset_server
                        .load_builder()
                        .with_settings::<ImageLoaderSettings>(|settings| {
                            settings
                                .sampler
                                .get_or_init_descriptor()
                                .set_address_mode(ImageAddressMode::Repeat);
                        })
                        .load("textures/uv_checker_bw.png"),
                ),
                perceptual_roughness: 0.9,
                ..default()
            }),
        ),
        Transform::from_xyz(0.0, 0.0, 1.5),
    ));

    let neutral = materials.add(StandardMaterial {
        base_color: Color::srgb(0.55, 0.54, 0.52),
        perceptual_roughness: 0.9,
        ..default()
    });

    for (z, normal) in [(-9.0, Vec3::Z), (12.0, Vec3::NEG_Z)] {
        let wall = meshes.add(raytraced(Plane3d::new(normal, Vec2::new(9.0, 4.0))));
        commands.spawn((
            RaytracingMesh3d(wall.clone()),
            Mesh3d(wall),
            MeshMaterial3d(neutral.clone()),
            Transform::from_xyz(0.0, 4.0, z),
        ));
    }

    for (x, normal, tint) in [
        (-9.0, Vec3::X, Color::srgb(0.6, 0.25, 0.22)),
        (9.0, Vec3::NEG_X, Color::srgb(0.22, 0.3, 0.6)),
    ] {
        let wall = meshes.add(raytraced(Plane3d::new(normal, Vec2::new(4.0, 10.5))));
        commands.spawn((
            RaytracingMesh3d(wall.clone()),
            Mesh3d(wall),
            MeshMaterial3d(materials.add(StandardMaterial {
                base_color: tint,
                perceptual_roughness: 0.9,
                ..default()
            })),
            Transform::from_xyz(x, 4.0, 1.5),
        ));
    }

    let ceiling = meshes.add(raytraced(Plane3d::new(Vec3::NEG_Y, Vec2::splat(10.5))));
    commands.spawn((
        RaytracingMesh3d(ceiling.clone()),
        Mesh3d(ceiling),
        MeshMaterial3d(neutral),
        Transform::from_xyz(0.0, 8.0, 1.5),
    ));

    let lamp = meshes.add(raytraced(Plane3d::new(Vec3::NEG_Y, Vec2::splat(1.75))));
    commands.spawn((
        RaytracingMesh3d(lamp.clone()),
        Mesh3d(lamp),
        MeshMaterial3d(materials.add(StandardMaterial {
            emissive: LinearRgba::rgb(40000.0, 38000.0, 34000.0),
            ..default()
        })),
        Transform::from_xyz(0.0, 7.8, 0.5),
    ));
}

examples/3d/solari.rs (line 254)

fn setup_many_lights(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    args: Res<Args>,
    #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))] dlss_rr_supported: Option<
        Res<DlssRayReconstructionSupported>,
    >,
) {
    let mut rng = ChaCha8Rng::seed_from_u64(42);

    let mut plane_mesh = Plane3d::default()
        .mesh()
        .size(400.0, 400.0)
        .build()
        .with_generated_tangents()
        .unwrap();
    match plane_mesh.attribute_mut(Mesh::ATTRIBUTE_UV_0).unwrap() {
        VertexAttributeValues::Float32x2(items) => {
            items.iter_mut().flatten().for_each(|x| *x *= 3.0);
        }
        _ => unreachable!(),
    }
    let plane_mesh = meshes.add(plane_mesh);
    let cube_mesh = meshes.add(
        Cuboid::default()
            .mesh()
            .build()
            .with_generated_tangents()
            .unwrap(),
    );
    let sphere_mesh = meshes.add(
        Sphere::new(1.0)
            .mesh()
            .build()
            .with_generated_tangents()
            .unwrap(),
    );

    commands
        .spawn((
            RaytracingMesh3d(plane_mesh.clone()),
            MeshMaterial3d(
                materials.add(StandardMaterial {
                    base_color_texture: Some(
                        asset_server
                            .load_builder()
                            .with_settings::<ImageLoaderSettings>(|settings| {
                                settings
                                    .sampler
                                    .get_or_init_descriptor()
                                    .set_address_mode(ImageAddressMode::Repeat);
                            })
                            .load("textures/uv_checker_bw.png"),
                    ),
                    perceptual_roughness: 0.0,
                    ..default()
                }),
            ),
        ))
        .insert_if(Mesh3d(plane_mesh), || args.pathtracer != Some(true));

    for _ in 0..8000 {
        commands
            .spawn((
                RaytracingMesh3d(cube_mesh.clone()),
                MeshMaterial3d(materials.add(StandardMaterial {
                    base_color: Color::srgb(rng.random(), rng.random(), rng.random()),
                    perceptual_roughness: rng.random(),
                    ..default()
                })),
                Transform::default()
                    .with_scale(Vec3 {
                        x: rng.random_range(0.2..=2.0),
                        y: rng.random_range(0.2..=2.0),
                        z: rng.random_range(0.2..=2.0),
                    })
                    .with_translation(Vec3::new(
                        rng.random_range(-180.0..=180.0),
                        0.2,
                        rng.random_range(-180.0..=180.0),
                    )),
            ))
            .insert_if(Mesh3d(cube_mesh.clone()), || args.pathtracer != Some(true));
    }

    for x in -10..=10 {
        for y in -10..=10 {
            commands
                .spawn((
                    RaytracingMesh3d(sphere_mesh.clone()),
                    MeshMaterial3d(
                        materials.add(StandardMaterial {
                            emissive: Color::linear_rgb(
                                rng.random::<f32>() * 60000.0,
                                rng.random::<f32>() * 60000.0,
                                rng.random::<f32>() * 60000.0,
                            )
                            .into(),
                            ..default()
                        }),
                    ),
                    Transform::default().with_translation(Vec3::new(
                        (x * 20) as f32,
                        7.0,
                        (y * 20) as f32,
                    )),
                ))
                .insert_if(Mesh3d(sphere_mesh.clone()), || {
                    args.pathtracer != Some(true)
                });
        }
    }

    let mut camera = commands.spawn((
        Camera3d::default(),
        Camera {
            clear_color: ClearColorConfig::Custom(Color::BLACK),
            ..default()
        },
        FreeCamera {
            walk_speed: 3.0,
            run_speed: 10.0,
            ..Default::default()
        },
        Transform::from_translation(Vec3::new(6.11329, 166.74896, 451.8226)).with_rotation(
            Quat::from_xyzw(-0.183938, 0.009093744, 0.0017017953, 0.9828943),
        ),
        // Msaa::Off and CameraMainTextureUsages with STORAGE_BINDING are required for Solari
        CameraMainTextureUsages::default().with(TextureUsages::STORAGE_BINDING),
        Msaa::Off,
        Bloom {
            intensity: 0.1,
            ..Bloom::NATURAL
        },
    ));

    if args.pathtracer == Some(true) {
        camera.insert(Pathtracer::default());
    } else {
        camera.insert(SolariLighting::default());
    }

    // Using DLSS Ray Reconstruction for denoising (and cheaper rendering via upscaling) is _highly_ recommended when using Solari
    #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
    if dlss_rr_supported.is_some() {
        camera.insert(Dlss::<DlssRayReconstructionFeature>::default());
    }

    commands.spawn((
        ControlText,
        Text::default(),
        Node {
            position_type: PositionType::Absolute,
            bottom: px(12.0),
            left: px(12.0),
            ..default()
        },
    ));

    commands.spawn((
        Node {
            position_type: PositionType::Absolute,
            right: px(0.0),
            padding: px(4.0).all(),
            border_radius: BorderRadius::bottom_left(px(4.0)),
            ..default()
        },
        BackgroundColor(Color::srgba(0.10, 0.10, 0.10, 0.8)),
        children![(
            PerformanceText,
            Text::default(),
            TextFont {
                font_size: FontSize::Px(8.0),
                ..default()
            },
        )],
    ));
}

Trait Implementations

impl Clone for ImageSampler

fn clone(&self) -> ImageSampler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ImageSampler

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

Formats the value using the given formatter.

impl Default for ImageSampler

fn default() -> ImageSampler

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ImageSampler

fn deserialize<__D>( __deserializer: __D, ) -> Result<ImageSampler, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Enum for ImageSampler

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

Returns a reference to the value of the field (in the current variant) with the given name.

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

Returns a reference to the value of the field (in the current variant) at the given index.

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

Returns a mutable reference to the value of the field (in the current variant) with the given name.

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

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

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

Returns the name of the field (in the current variant) with the given index.

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

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn to_dynamic_enum(&self) -> Result<DynamicEnum, ReflectCloneError>

Creates a new DynamicEnum from this enum.

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

fn get_represented_enum_info(&self) -> Option<&'static EnumInfo>

Will return None if TypeInfo is not available.

impl FromArg for ImageSampler

type This<'from_arg> = ImageSampler

The type to convert into.

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

Creates an item from an argument.

impl FromReflect for ImageSampler

fn from_reflect( __param0: &(dyn PartialReflect + 'static), ) -> Option<ImageSampler>

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 GetOwnership for ImageSampler

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for ImageSampler

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 IntoReturn for ImageSampler

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

where ImageSampler: 'into_return,

Converts Self into a Return value.

impl PartialEq for ImageSampler

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

Equality operator ==.

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

Inequality operator !=.

impl PartialReflect for ImageSampler

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_param: &(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<ImageSampler>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<ImageSampler>, ) -> 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<ImageSampler>) -> 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) -> Result<Box<dyn PartialReflect>, ReflectCloneError>

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 Reflect for ImageSampler

fn into_any(self: Box<ImageSampler>) -> 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<ImageSampler>) -> 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 Serialize for ImageSampler

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 StructuralPartialEq for ImageSampler

impl TypePath for ImageSampler

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 ImageSampler

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.