Struct Cuboid 

pub struct Cuboid {
    pub half_size: Vec3,
}

A cuboid primitive, which is like a cube, except that the x, y, and z dimensions are not required to be the same.

Fields

half_size: Vec3

Half of the width, height and depth of the cuboid

Implementations

impl Cuboid

pub const fn new(x_length: f32, y_length: f32, z_length: f32) -> Cuboid

Create a new Cuboid from a full x, y, and z length

Examples found in repository

examples/async_tasks/async_compute.rs (line 49)

fn add_assets(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    let box_mesh_handle = meshes.add(Cuboid::new(0.25, 0.25, 0.25));
    commands.insert_resource(BoxMeshHandle(box_mesh_handle));

    let box_material_handle = materials.add(Color::srgb(1.0, 0.2, 0.3));
    commands.insert_resource(BoxMaterialHandle(box_material_handle));
}

examples/async_tasks/async_channel_pattern.rs (line 122)

fn setup_assets(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // Create and store a cube mesh
    let box_mesh_handle = meshes.add(Cuboid::new(0.4, 0.4, 0.4));
    commands.insert_resource(BoxMeshHandle(box_mesh_handle));

    // Create and store a red material
    let box_material_handle = materials.add(Color::srgb(1.0, 0.2, 0.3));
    commands.insert_resource(BoxMaterialHandle(box_material_handle));
}

examples/shader_advanced/render_depth_to_texture.rs (line 204)

fn spawn_rotating_cube(
    commands: &mut Commands,
    meshes: &mut Assets<Mesh>,
    standard_materials: &mut Assets<StandardMaterial>,
) {
    let cube_handle = meshes.add(Cuboid::new(3.0, 3.0, 3.0));
    let rotating_cube_material_handle = standard_materials.add(StandardMaterial {
        base_color: Color::WHITE,
        unlit: false,
        ..default()
    });
    commands.spawn((
        Mesh3d(cube_handle.clone()),
        MeshMaterial3d(rotating_cube_material_handle),
        Transform::IDENTITY,
        RotatingCube,
    ));
}

examples/3d/ssr.rs (line 285)

fn spawn_cube(
    commands: &mut Commands,
    asset_server: &AssetServer,
    meshes: &mut Assets<Mesh>,
    standard_materials: &mut Assets<StandardMaterial>,
) {
    commands
        .spawn((
            Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
            MeshMaterial3d(standard_materials.add(StandardMaterial {
                base_color: Color::from(WHITE),
                base_color_texture: Some(asset_server.load("branding/icon.png")),
                ..default()
            })),
            Transform::from_xyz(0.0, 0.5, 0.0),
        ))
        .insert(CubeModel);
}

examples/picking/debug_picking.rs (line 95)

fn on_click_spawn_cube(
    _click: On<PointerClick>,
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut num: Local<usize>,
) {
    commands
        .spawn((
            Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
            MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
            Transform::from_xyz(0.0, 0.25 + 0.55 * *num as f32, 0.0),
        ))
        // With the MeshPickingPlugin added, you can add pointer event observers to meshes:
        .observe(on_drag_rotate);
    *num += 1;
}

examples/picking/simple_picking.rs (line 69)

fn on_click_spawn_cube(
    _click: On<PointerClick>,
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut num: Local<usize>,
) {
    commands
        .spawn((
            Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
            MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
            Transform::from_xyz(0.0, 0.25 + 0.55 * *num as f32, 0.0),
        ))
        // With the MeshPickingPlugin added, you can add pointer event observers to meshes:
        .observe(on_drag_rotate);
    *num += 1;
}

Additional examples can be found in:

• examples/3d/clustered_decals.rs
• examples/3d/3d_scene.rs
• examples/app/externally_driven_headless_renderer.rs
• examples/shader_advanced/manual_material.rs
• examples/3d/light_textures.rs
• examples/shader_advanced/mesh_shader_intro.rs
• examples/3d/order_independent_transparency.rs
• examples/3d/parenting.rs
• examples/remote/server.rs
• examples/3d/animated_material.rs
• examples/camera/custom_projection.rs
• examples/diagnostics/log_diagnostics.rs
• examples/dev_tools/infinite_grid.rs
• examples/3d/atmospheric_fog.rs
• examples/window/low_power.rs
• examples/shader_advanced/custom_shader_instancing.rs
• examples/testbed/ui.rs
• examples/camera/first_person_view_model.rs
• examples/gizmos/axes.rs
• examples/camera/free_camera_controller.rs
• examples/app/headless_renderer.rs
• examples/3d/occlusion_culling.rs
• examples/ui/widgets/viewport_node.rs
• examples/app/render_recovery.rs
• examples/shader_advanced/custom_render_phase.rs
• examples/audio/spatial_audio_3d.rs
• examples/3d/fog.rs
• examples/3d/motion_blur.rs
• examples/stress_tests/many_cameras_lights.rs
• examples/3d/anti_aliasing.rs
• examples/gizmos/3d_gizmos.rs
• examples/3d/scrolling_fog.rs
• examples/3d/render_to_texture.rs
• examples/asset/repeated_texture.rs
• examples/3d/spotlight.rs
• examples/testbed/3d.rs
• examples/gizmos/light_gizmos.rs
• examples/gizmos/transform_gizmo.rs
• examples/3d/parallax_mapping.rs
• examples/3d/deferred_rendering.rs
• examples/animation/animated_transform.rs
• examples/3d/lighting.rs
• examples/3d/transmission.rs

pub const fn from_size(size: Vec3) -> Cuboid

Create a new Cuboid from a given full size

Examples found in repository

examples/math/custom_primitives.rs (line 330)

fn bounding_shapes_3d(
    shapes: Query<&Transform, With<Shape3d>>,
    mut gizmos: Gizmos,
    bounding_shape: Res<State<BoundingShape>>,
) {
    for transform in shapes.iter() {
        match bounding_shape.get() {
            BoundingShape::None => (),
            BoundingShape::BoundingBox => {
                // Get the AABB of the extrusion with the rotation and translation of the mesh.
                let aabb = EXTRUSION.aabb_3d(transform.to_isometry());

                gizmos.primitive_3d(
                    &Cuboid::from_size(Vec3::from(aabb.half_size()) * 2.),
                    aabb.center(),
                    WHITE,
                );
            }
            BoundingShape::BoundingSphere => {
                // Get the bounding sphere of the extrusion with the rotation and translation of the mesh.
                let bounding_sphere = EXTRUSION.bounding_sphere(transform.to_isometry());

                gizmos.sphere(bounding_sphere.center(), bounding_sphere.radius(), WHITE);
            }
        }
    }
}

examples/movement/smooth_follow.rs (line 113)

fn move_target(
    mut target: Single<&mut Transform, With<TargetSphere>>,
    target_speed: Res<TargetSphereSpeed>,
    mut target_pos: ResMut<TargetPosition>,
    time: Res<Time>,
    mut rng: ResMut<RandomSource>,
) {
    match Dir3::new(target_pos.0 - target.translation) {
        // The target and the present position of the target sphere are far enough to have a well-
        // defined direction between them, so let's move closer:
        Ok(dir) => {
            let delta_time = time.delta_secs();
            let abs_delta = (target_pos.0 - target.translation).norm();

            // Avoid overshooting in case of high values of `delta_time`:
            let magnitude = f32::min(abs_delta, delta_time * target_speed.0);
            target.translation += dir * magnitude;
        }

        // The two are really close, so let's generate a new target position:
        Err(_) => {
            let legal_region = Cuboid::from_size(Vec3::splat(4.0));
            *target_pos = TargetPosition(legal_region.sample_interior(&mut rng.0));
        }
    }
}

examples/stress_tests/many_materials.rs (line 79)

fn setup(
    mut commands: Commands,
    args: Res<Args>,
    mesh_assets: ResMut<Assets<Mesh>>,
    material_assets: ResMut<Assets<StandardMaterial>>,
) {
    warn!(include_str!("warning_string.txt"));

    let args = args.into_inner();
    let material_assets = material_assets.into_inner();
    let mesh_assets = mesh_assets.into_inner();
    let n = args.grid_size;

    // Camera
    let w = n as f32;
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(w * 1.25, w + 1.0, w * 1.25)
            .looking_at(Vec3::new(0.0, (w * -1.1) + 1.0, 0.0), Vec3::Y),
    ));

    // Light
    commands.spawn((
        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, 1.0, -PI / 4.)),
        DirectionalLight {
            illuminance: 3000.0,
            shadow_maps_enabled: true,
            ..default()
        },
    ));

    // Cubes
    let mesh_handle = mesh_assets.add(Cuboid::from_size(Vec3::ONE));
    for x in 0..n {
        for z in 0..n {
            commands.spawn((
                Mesh3d(mesh_handle.clone()),
                MeshMaterial3d(material_assets.add(Color::WHITE)),
                Transform::from_translation(Vec3::new(x as f32, 0.0, z as f32)),
            ));
        }
    }
}

examples/shader/storage_buffer.rs (line 38)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut buffers: ResMut<Assets<ShaderBuffer>>,
    mut materials: ResMut<Assets<CustomMaterial>>,
) {
    // Example data for the storage buffer
    let color_data: Vec<[f32; 4]> = vec![
        [1.0, 0.0, 0.0, 1.0],
        [0.0, 1.0, 0.0, 1.0],
        [0.0, 0.0, 1.0, 1.0],
        [1.0, 1.0, 0.0, 1.0],
        [0.0, 1.0, 1.0, 1.0],
    ];

    let colors = buffers.add(ShaderBuffer::from(color_data));

    let mesh_handle = meshes.add(Cuboid::from_size(Vec3::splat(0.3)));
    // Create the custom material with the storage buffer
    let material_handle = materials.add(CustomMaterial {
        colors: colors.clone(),
    });

    commands.insert_resource(CustomMaterialHandle(material_handle.clone()));

    // Spawn cubes with the custom material
    let mut current_color_id: u32 = 0;
    for i in -6..=6 {
        for j in -3..=3 {
            commands.spawn((
                Mesh3d(mesh_handle.clone()),
                MeshMaterial3d(material_handle.clone()),
                MeshTag::new(current_color_id % 5),
                Transform::from_xyz(i as f32, j as f32, 0.0),
            ));
            current_color_id += 1;
        }
    }

    // Camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 0.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

examples/3d/order_independent_transparency.rs (line 524)

fn spawn_occlusion_test(commands: &mut Commands, resources: &mut SceneResources) {
    let meshes = &mut resources.meshes;
    let materials = &mut resources.materials;

    let sphere_handle = meshes.add(Sphere::new(1.0).mesh());
    let cube_handle = meshes.add(Cuboid::from_size(Vec3::ONE).mesh());
    let cube_material = materials.add(Color::srgb(0.8, 0.7, 0.6));

    // front
    let x = -2.5;
    commands.spawn((
        Mesh3d(cube_handle.clone()),
        MeshMaterial3d(cube_material.clone()),
        Transform::from_xyz(x, 0.0, 2.0),
    ));
    commands.spawn((
        Mesh3d(sphere_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: RED.with_alpha(0.5).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        Transform::from_xyz(x, 0., 0.),
    ));

    // intersection
    commands.spawn((
        Mesh3d(cube_handle.clone()),
        MeshMaterial3d(cube_material.clone()),
        Transform::from_xyz(x, 0.0, 1.0),
    ));
    commands.spawn((
        Mesh3d(sphere_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: RED.with_alpha(0.5).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        Transform::from_xyz(0., 0., 0.),
    ));

    // back
    let x = 2.5;
    commands.spawn((
        Mesh3d(cube_handle.clone()),
        MeshMaterial3d(cube_material.clone()),
        Transform::from_xyz(x, 0.0, -2.0),
    ));
    commands.spawn((
        Mesh3d(sphere_handle.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: RED.with_alpha(0.5).into(),
            alpha_mode: AlphaMode::Blend,
            ..default()
        })),
        Transform::from_xyz(x, 0., 0.),
    ));
}

examples/shader/automatic_instancing.rs (line 36)

fn setup(
    mut commands: Commands,
    assets: Res<AssetServer>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<CustomMaterial>>,
) {
    // We will use this image as our external data for our material to sample from in the vertex shader
    let image = assets.load("branding/icon.png");

    // Our single mesh handle that will be instanced
    let mesh_handle = meshes.add(Cuboid::from_size(Vec3::splat(0.01)));

    // Create the custom material with a reference to our texture
    // Automatic instancing works with any Material, including the `StandardMaterial`.
    // This custom material is used to demonstrate the optional `MeshTag` feature.
    let material_handle = materials.add(CustomMaterial {
        image: image.clone(),
    });

    // We're hardcoding the image dimensions for simplicity
    let image_dims = UVec2::new(256, 256);
    let total_pixels = image_dims.x * image_dims.y;

    for index in 0..total_pixels {
        // Get x,y from index - x goes left to right, y goes top to bottom
        let x = index % image_dims.x;
        let y = index / image_dims.x;

        // Convert to centered world coordinates
        let world_x = (x as f32 - image_dims.x as f32 / 2.0) / 50.0;
        let world_y = -((y as f32 - image_dims.y as f32 / 2.0) / 50.0); // Still need negative for world space

        commands.spawn((
            // For automatic instancing to take effect you need to
            // use the same mesh handle and material handle for each instance
            Mesh3d(mesh_handle.clone()),
            MeshMaterial3d(material_handle.clone()),
            // This is an optional component that can be used to help tie external data to a mesh instance
            MeshTag::new(index),
            Transform::from_xyz(world_x, world_y, 0.0),
        ));
    }

    // Camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 0.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

Additional examples can be found in:

• examples/stress_tests/bevymark_3d.rs
• examples/stress_tests/many_cubes.rs

pub fn from_corners(point1: Vec3, point2: Vec3) -> Cuboid

Create a new Cuboid from two corner points

pub const fn from_length(length: f32) -> Cuboid

Create a Cuboid from a single length. The resulting Cuboid will be the same size in every direction.

Examples found in repository

examples/shader_advanced/deferred_raymarch.rs (line 70)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(4.0, 3.0, 6.0).looking_at(Vec3::new(0.0, 0.2, 0.0), Vec3::Y),
        // Deferred rendering requires MSAA to be off.
        Msaa::Off,
        DepthPrepass,
        DeferredPrepass,
        AmbientLight {
            brightness: 200.0,
            ..default()
        },
        FreeCamera::default(),
    ));

    // A ground plane that catches the SDF's shadow
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(20.0, 20.0))),
        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
        Transform::from_xyz(0.0, -1.5, 0.0),
    ));

    // A "regular" mesh cube
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::from_length(1.2))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::srgb(0.2, 0.4, 0.9),
            perceptual_roughness: 0.4,
            ..default()
        })),
        Transform::from_xyz(2.2, -0.9, 0.5),
    ));

    commands.spawn((
        DirectionalLight {
            illuminance: 8_000.0,
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(4.0, 8.0, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));
}

tests/window/desktop_request_redraw.rs (line 80)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 5.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    commands.spawn((
        PointLight {
            intensity: 1e6,
            ..Default::default()
        },
        Transform::from_xyz(-1.0, 5.0, 1.0),
    ));

    let node = Node {
        display: Display::Block,
        padding: UiRect::all(Val::Px(10.0)),
        row_gap: Val::Px(10.0),
        ..Default::default()
    };

    commands.spawn((
        node.clone(),
        children![
            (
                node.clone(),
                children![Text::new("Right click cube to pause animation")]
            ),
            (
                node.clone(),
                children![Text::new("Left click cube to start animation")]
            )
        ],
    ));

    commands
        .spawn((
            Mesh3d(meshes.add(Cuboid::from_length(1.0))),
            MeshMaterial3d(materials.add(Color::WHITE)),
            AnimationActive,
        ))
        .observe(
            |click: On<PointerClick>, mut commands: Commands| match click.button {
                PointerButton::Primary => {
                    commands.entity(click.entity).insert(AnimationActive);
                }
                PointerButton::Secondary => {
                    commands.entity(click.entity).remove::<AnimationActive>();
                }
                _ => {}
            },
        );
}

examples/animation/eased_motion.rs (line 41)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut animation_graphs: ResMut<Assets<AnimationGraph>>,
    mut animation_clips: ResMut<Assets<AnimationClip>>,
) {
    // Create the animation:
    let AnimationInfo {
        target_name: animation_target_name,
        target_id: animation_target_id,
        graph: animation_graph,
        node_index: animation_node_index,
    } = AnimationInfo::create(&mut animation_graphs, &mut animation_clips);

    // Build an animation player that automatically plays the animation.
    let mut animation_player = AnimationPlayer::default();
    animation_player.play(animation_node_index).repeat();

    // A cube together with the components needed to animate it
    let cube_entity = commands
        .spawn((
            Mesh3d(meshes.add(Cuboid::from_length(2.0))),
            MeshMaterial3d(materials.add(Color::from(ORANGE))),
            Transform::from_translation(vec3(-6., 2., 0.)),
            animation_target_name,
            animation_player,
            AnimationGraphHandle(animation_graph),
        ))
        .id();

    commands
        .entity(cube_entity)
        .insert((animation_target_id, AnimatedBy(cube_entity)));

    // Some light to see something
    commands.spawn((
        PointLight {
            shadow_maps_enabled: true,
            intensity: 10_000_000.,
            range: 100.0,
            ..default()
        },
        Transform::from_xyz(8., 16., 8.),
    ));

    // Ground plane
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(50., 50.))),
        MeshMaterial3d(materials.add(Color::from(SILVER))),
    ));

    // The camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0., 6., 12.).looking_at(Vec3::new(0., 1.5, 0.), Vec3::Y),
    ));
}

examples/math/random_sampling.rs (line 68)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // Use seeded rng and store it in a resource; this makes the random output reproducible.
    let seeded_rng = ChaCha8Rng::seed_from_u64(19878367467712);
    commands.insert_resource(RandomSource(seeded_rng));

    // Make a plane for establishing space.
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(12.0, 12.0))),
        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
        Transform::from_xyz(0.0, -2.5, 0.0),
    ));

    // Store the shape we sample from in a resource:
    let shape = Cuboid::from_length(2.9);
    commands.insert_resource(SampledShape(shape));

    // The sampled shape shown transparently:
    commands.spawn((
        Mesh3d(meshes.add(shape)),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::srgba(0.2, 0.1, 0.6, 0.3),
            alpha_mode: AlphaMode::Blend,
            cull_mode: None,
            ..default()
        })),
    ));

    // A light:
    commands.spawn((
        PointLight {
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(4.0, 8.0, 4.0),
    ));

    // A camera:
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(-2.0, 3.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    // Store the mesh and material for sample points in resources:
    commands.insert_resource(PointMesh(
        meshes.add(
            Sphere::new(0.03)
                .mesh()
                .kind(SphereKind::Ico { subdivisions: 3 }),
        ),
    ));
    commands.insert_resource(PointMaterial(materials.add(StandardMaterial {
        base_color: Color::srgb(1.0, 0.8, 0.8),
        metallic: 0.8,
        ..default()
    })));

    // Instructions for the example:
    commands.spawn((
        Text::new(
            "Controls:\n\
            M: Toggle between sampling boundary and interior.\n\
            R: Restart (erase all samples).\n\
            S: Add one random sample.\n\
            D: Add 100 random samples.\n\
            Rotate camera by holding left mouse and panning left/right.",
        ),
        Node {
            position_type: PositionType::Absolute,
            top: px(12),
            left: px(12),
            ..default()
        },
    ));

    // The mode starts with interior points.
    commands.insert_resource(Mode::Interior);

    // Starting mouse-pressed state is false.
    commands.insert_resource(MousePressed(false));
}

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

fn setup(
    mut commands: Commands,
    mut standard_materials: ResMut<Assets<StandardMaterial>>,
    mut debug_materials: ResMut<Assets<MeshletDebugMaterial>>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut meshlets: ResMut<Assets<MeshletMesh>>,
    mut images: ResMut<Assets<Image>>,
) {
    commands.spawn_scene_list(bsn_list! {
        Camera3d
        Transform::from_translation(Vec3::new(0.0, 1.5, -3.0))
            .looking_at(vec3(0.0, 0.0, 1.5), Vec3::Y)
        Msaa::Off
        FreeCamera
        --
        DirectionalLight {
            illuminance: light_consts::lux::FULL_DAYLIGHT
        }
        Transform::from_xyz(0.0, 1.0, -0.5).looking_at(Vec3::ZERO, Vec3::Z)
        --
        Text::new("M: toggle debug material")
        Node {
            position_type: PositionType::Absolute,
            top: px(12),
            left: px(12),
        }
        --
        Text::new("meshlet")
        Node {
            position_type: PositionType::Absolute,
            bottom: px(12),
            left: percent(25),
        }
        --
        Text::new("regular")
        Node {
            position_type: PositionType::Absolute,
            bottom: px(12),
            right: percent(25),
        }
    });

    let sphere_mesh = Sphere::default().mesh().uv(48, 27);
    let cube_mesh = Cuboid::from_length(0.8).mesh().build();

    let sphere_meshlet = MeshletMesh::from_mesh(
        &sphere_mesh,
        MESHLET_DEFAULT_VERTEX_POSITION_QUANTIZATION_FACTOR,
    )
    .unwrap();

    let cube_meshlet = MeshletMesh::from_mesh(
        &cube_mesh,
        MESHLET_DEFAULT_VERTEX_POSITION_QUANTIZATION_FACTOR,
    )
    .unwrap();

    let sphere_mesh_asset = meshes.add(sphere_mesh);
    let cube_mesh_asset = meshes.add(cube_mesh);

    let sphere_meshlet_asset = meshlets.add(sphere_meshlet);
    let cube_meshlet_asset = meshlets.add(cube_meshlet);

    let mipmap_material = mipmap_material(&mut standard_materials, &mut images);
    let debug_material = debug_materials.add(MeshletDebugMaterial::default());

    for distance in [0.0, 8.0, 32.0, 128.0] {
        commands.spawn_scene_list(bsn_list! {
            Mesh3d({sphere_mesh_asset.clone()})
            MeshMaterial3d::<StandardMaterial>({mipmap_material.clone()})
            Transform::from_xyz(-0.5, 0.0, distance)
            --
            MeshletMesh3d({sphere_meshlet_asset.clone()})
            MeshMaterial3d::<StandardMaterial>({mipmap_material.clone()})
            Transform::from_xyz(0.5, 0.0, distance)
            --
            Mesh3d({cube_mesh_asset.clone()})
            MeshMaterial3d::<StandardMaterial>({mipmap_material.clone()})
            Transform::from_xyz(-1.5, 0.0, distance)
            --
            MeshletMesh3d({cube_meshlet_asset.clone()})
            MeshMaterial3d::<StandardMaterial>({mipmap_material.clone()})
            Transform::from_xyz(1.5, 0.0, distance)
        });
    }

    commands.insert_resource(Materials {
        mipmap: mipmap_material,
        debug: debug_material,
    });
}

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

fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))] dlss_rr_supported: Option<
        Res<DlssRayReconstructionSupported>,
    >,
) {
    let test_material = materials.add(StandardMaterial {
        base_color: METALLIC_BASE_COLOR,
        metallic: 1.0,
        perceptual_roughness: INITIAL_ROUGHNESS,
        ..default()
    });
    commands.insert_resource(TestMaterial(test_material.clone()));

    let mirror = materials.add(StandardMaterial {
        base_color: Color::srgb(0.95, 0.95, 0.97),
        metallic: 1.0,
        perceptual_roughness: 0.0,
        ..default()
    });

    spawn_room(&mut commands, &asset_server, &mut meshes, &mut materials);

    let panel = meshes.add(raytraced(Plane3d::new(Vec3::Z, Vec2::new(2.0, 1.5))));
    commands.spawn((
        RaytracingMesh3d(panel.clone()),
        Mesh3d(panel),
        MeshMaterial3d(test_material.clone()),
        Transform::from_xyz(MIRROR_BASE_X, 1.7, -3.0).with_rotation(mirror_rotation(0.0)),
        PanningMirror,
    ));

    commands
        .spawn((
            WorldAssetRoot(asset_server.load(
                GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf"),
            )),
            Transform::from_xyz(4.8, 0.0, -1.6)
                .with_scale(Vec3::splat(4.0))
                .with_rotation(Quat::from_rotation_y(-0.4)),
        ))
        .observe(add_raytracing_meshes_on_scene_load);

    let cube = meshes.add(raytraced(Cuboid::from_length(0.6)));
    commands.spawn((
        RaytracingMesh3d(cube.clone()),
        Mesh3d(cube.clone()),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::srgb(0.9, 0.15, 0.05),
            perceptual_roughness: 0.6,
            ..default()
        })),
        Transform::from_xyz(3.5, 1.5, 2.5),
        OrbitingObject,
    ));

    let moving_sphere = meshes.add(raytraced(Sphere::new(0.8).mesh().build()));
    commands.spawn((
        RaytracingMesh3d(moving_sphere.clone()),
        Mesh3d(moving_sphere),
        MeshMaterial3d(test_material),
        Transform::from_xyz(0.0, 0.9, 3.6),
        SlidingObject,
    ));

    let nested = meshes.add(raytraced(Plane3d::new(Vec3::Z, Vec2::new(1.3, 1.9))));
    for (x, yaw) in [(-5.2, 1.04), (-1.8, -1.04)] {
        commands.spawn((
            RaytracingMesh3d(nested.clone()),
            Mesh3d(nested.clone()),
            MeshMaterial3d(mirror.clone()),
            Transform::from_xyz(x, 2.0, -3.5).with_rotation(Quat::from_rotation_y(yaw)),
        ));
    }

    commands.spawn((
        RaytracingMesh3d(cube.clone()),
        Mesh3d(cube),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::srgb(0.95, 0.75, 0.1),
            perceptual_roughness: 0.6,
            ..default()
        })),
        Transform::from_xyz(-3.5, 2.0, -4.0).with_scale(Vec3::splat(0.6)),
    ));

    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()
        },
        Transform::from_xyz(0.0, 2.8, 9.5).looking_at(Vec3::new(0.0, 1.6, -1.0), Vec3::Y),
        Exposure::INDOOR,
        CameraMainTextureUsages::default().with(TextureUsages::STORAGE_BINDING),
        Msaa::Off,
        SolariLighting::default(),
    ));

    #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
    if dlss_rr_supported.is_some() {
        camera.insert(Dlss::<DlssRayReconstructionFeature>::default());
    }
    let _ = &mut camera;

    spawn_ui(&mut commands);
}

Additional examples can be found in:

• examples/3d/decal.rs

pub fn size(&self) -> Vec3

Get the size of the cuboid

pub fn closest_point(&self, point: Vec3) -> Vec3

Finds the point on the cuboid that is closest to the given point.

If the point is outside the cuboid, the returned point will be on the surface of the cuboid. Otherwise, it will be inside the cuboid and returned as is.

Trait Implementations

impl Bounded3d for Cuboid

fn aabb_3d(&self, isometry: impl Into<Isometry3d>) -> Aabb3d

Get an axis-aligned bounding box for the shape translated and rotated by the given isometry.

fn bounding_sphere(&self, isometry: impl Into<Isometry3d>) -> BoundingSphere

Get a bounding sphere for the shape translated and rotated by the given isometry.

impl Clone for Cuboid

fn clone(&self) -> Cuboid

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Cuboid

impl Debug for Cuboid

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

Formats the value using the given formatter.

impl Default for Cuboid

fn default() -> Cuboid

Returns the default Cuboid with a width, height, and depth of 1.0.

impl<'de> Deserialize<'de> for Cuboid

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Cuboid> for Mesh

fn from(cuboid: Cuboid) -> Mesh

Converts to this type from the input type.

impl From<Cuboid> for Aabb3d

fn from(value: Cuboid) -> Aabb3d

Converts to this type from the input type.

impl FromArg for Cuboid

type This<'from_arg> = Cuboid

The type to convert into.

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

Creates an item from an argument.

impl FromReflect for Cuboid

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

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 Cuboid

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for Cuboid

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<Config, Clear> GizmoPrimitive3d<Cuboid> for GizmoBuffer<Config, Clear>

where Config: GizmoConfigGroup, Clear: 'static + Send + Sync,

type Output<'a> = () where GizmoBuffer<Config, Clear>: 'a

The output of primitive_3d. This is a builder to set non-default values.

fn primitive_3d( &mut self, primitive: &Cuboid, isometry: impl Into<Isometry3d>, color: impl Into<Color>, ) -> <GizmoBuffer<Config, Clear> as GizmoPrimitive3d<Cuboid>>::Output<'_>

Renders a 3D primitive with its associated details.

impl IntoReturn for Cuboid

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

where Cuboid: 'into_return,

Converts Self into a Return value.

impl Measured3d for Cuboid

fn area(&self) -> f32

Get the surface area of the cuboid

fn volume(&self) -> f32

Get the volume of the cuboid

impl Meshable for Cuboid

type Output = CuboidMeshBuilder

The output of Self::mesh. This will be a MeshBuilder used for creating a Mesh.

fn mesh(&self) -> <Cuboid as Meshable>::Output

Creates a Mesh for a shape.

impl PartialEq for Cuboid

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

Equality operator ==.

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

Inequality operator !=.

impl PartialReflect for Cuboid

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<Cuboid>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Cuboid>, ) -> 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<Cuboid>) -> 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_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 reflect_hash(&self) -> Option<u64>

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

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Primitive3d for Cuboid

impl Reflect for Cuboid

fn into_any(self: Box<Cuboid>) -> 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<Cuboid>) -> 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 Cuboid

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 ShapeSample for Cuboid

type Output = Vec3

The type of vector returned by the sample methods, Vec2 for 2D shapes and Vec3 for 3D shapes.

fn sample_interior<R>(&self, rng: &mut R) -> Vec3

where R: RngExt + ?Sized,

Uniformly sample a point from inside the area/volume of this shape, centered on 0.

fn sample_boundary<R>(&self, rng: &mut R) -> Vec3

where R: RngExt + ?Sized,

Uniformly sample a point from the surface of this shape, centered on 0.

fn interior_dist(self) -> impl Distribution<Self::Output>

where Self: Sized,

Extract a Distribution whose samples are points of this shape’s interior, taken uniformly.

fn boundary_dist(self) -> impl Distribution<Self::Output>

where Self: Sized,

Extract a Distribution whose samples are points of this shape’s boundary, taken uniformly.

impl Struct for Cuboid

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) -> Result<DynamicStruct, ReflectCloneError>

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 Cuboid

impl TypePath for Cuboid

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 Cuboid

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.