Merge branch 'main' into main

assets/shaders/array_texture.wgsl

@@ -36,7 +36,7 @@ fn fragment(
         is_front,
     );
 
-    pbr_input.is_orthographic = view.projection[3].w == 1.0;
+    pbr_input.is_orthographic = view.clip_from_view[3].w == 1.0;
 
     pbr_input.N = normalize(pbr_input.world_normal);
 

assets/shaders/custom_gltf_2d.wgsl

@@ -1,6 +1,6 @@
 #import bevy_sprite::{
     mesh2d_view_bindings::globals,
-    mesh2d_functions::{get_model_matrix, mesh2d_position_local_to_clip},
+    mesh2d_functions::{get_world_from_local, mesh2d_position_local_to_clip},
 }
 
 struct Vertex {
@@ -19,8 +19,8 @@ struct VertexOutput {
 @vertex
 fn vertex(vertex: Vertex) -> VertexOutput {
     var out: VertexOutput;
-    let model = get_model_matrix(vertex.instance_index);
-    out.clip_position = mesh2d_position_local_to_clip(model, vec4<f32>(vertex.position, 1.0));
+    let world_from_local = get_world_from_local(vertex.instance_index);
+    out.clip_position = mesh2d_position_local_to_clip(world_from_local, vec4<f32>(vertex.position, 1.0));
     out.color = vertex.color;
     out.barycentric = vertex.barycentric;
     return out;

assets/shaders/custom_vertex_attribute.wgsl

@@ -1,4 +1,4 @@
-#import bevy_pbr::mesh_functions::{get_model_matrix, mesh_position_local_to_clip}
+#import bevy_pbr::mesh_functions::{get_world_from_local, mesh_position_local_to_clip}
 
 struct CustomMaterial {
     color: vec4<f32>,
@@ -20,7 +20,7 @@ struct VertexOutput {
 fn vertex(vertex: Vertex) -> VertexOutput {
     var out: VertexOutput;
     out.clip_position = mesh_position_local_to_clip(
-        get_model_matrix(vertex.instance_index),
+        get_world_from_local(vertex.instance_index),
         vec4<f32>(vertex.position, 1.0),
     );
     out.blend_color = vertex.blend_color;

assets/shaders/instancing.wgsl

@@ -1,4 +1,4 @@
-#import bevy_pbr::mesh_functions::{get_model_matrix, mesh_position_local_to_clip}
+#import bevy_pbr::mesh_functions::{get_world_from_local, mesh_position_local_to_clip}
 
 struct Vertex {
     @location(0) position: vec3<f32>,
@@ -18,12 +18,12 @@ struct VertexOutput {
 fn vertex(vertex: Vertex) -> VertexOutput {
     let position = vertex.position * vertex.i_pos_scale.w + vertex.i_pos_scale.xyz;
     var out: VertexOutput;
-    // NOTE: Passing 0 as the instance_index to get_model_matrix() is a hack
+    // NOTE: Passing 0 as the instance_index to get_world_from_local() is a hack
     // for this example as the instance_index builtin would map to the wrong
     // index in the Mesh array. This index could be passed in via another
     // uniform instead but it's unnecessary for the example.
     out.clip_position = mesh_position_local_to_clip(
-        get_model_matrix(0u),
+        get_world_from_local(0u),
         vec4<f32>(position, 1.0)
     );
     out.color = vertex.i_color;

assets/shaders/irradiance_volume_voxel_visualization.wgsl

@@ -3,8 +3,8 @@
 #import bevy_pbr::mesh_view_bindings
 
 struct VoxelVisualizationIrradianceVolumeInfo {
-    transform: mat4x4<f32>,
-    inverse_transform: mat4x4<f32>,
+    world_from_voxel: mat4x4<f32>,
+    voxel_from_world: mat4x4<f32>,
     resolution: vec3<u32>,
     // A scale factor that's applied to the diffuse and specular light from the
     // light probe. This is in units of cd/m² (candela per square meter).
@@ -18,12 +18,12 @@ var<uniform> irradiance_volume_info: VoxelVisualizationIrradianceVolumeInfo;
 fn fragment(mesh: VertexOutput) -> @location(0) vec4<f32> {
     // Snap the world position we provide to `irradiance_volume_light()` to the
     // middle of the nearest texel.
-    var unit_pos = (irradiance_volume_info.inverse_transform *
+    var unit_pos = (irradiance_volume_info.voxel_from_world *
         vec4(mesh.world_position.xyz, 1.0f)).xyz;
     let resolution = vec3<f32>(irradiance_volume_info.resolution);
     let stp = clamp((unit_pos + 0.5) * resolution, vec3(0.5f), resolution - vec3(0.5f));
     let stp_rounded = round(stp - 0.5f) + 0.5f;
-    let rounded_world_pos = (irradiance_volume_info.transform * vec4(stp_rounded, 1.0f)).xyz;
+    let rounded_world_pos = (irradiance_volume_info.world_from_voxel * vec4(stp_rounded, 1.0f)).xyz;
 
     // `irradiance_volume_light()` multiplies by intensity, so cancel it out.
     // If we take intensity into account, the cubes will be way too bright.

crates/bevy_core_pipeline/src/prepass/mod.rs

@@ -71,8 +71,8 @@ pub struct DeferredPrepass;
 
 #[derive(Component, ShaderType, Clone)]
 pub struct PreviousViewData {
-    pub inverse_view: Mat4,
-    pub view_proj: Mat4,
+    pub view_from_world: Mat4,
+    pub clip_from_world: Mat4,
 }
 
 #[derive(Resource, Default)]

crates/bevy_core_pipeline/src/skybox/skybox.wgsl

@@ -24,7 +24,7 @@ fn coords_to_ray_direction(position: vec2<f32>, viewport: vec4<f32>) -> vec3<f32
     // fragment position.
     // Use the position on the near clipping plane to avoid -inf world position
     // because the far plane of an infinite reverse projection is at infinity.
-    let view_position_homogeneous = view.inverse_projection * vec4(
+    let view_position_homogeneous = view.view_from_clip * vec4(
         coords_to_viewport_uv(position, viewport) * vec2(2.0, -2.0) + vec2(-1.0, 1.0),
         1.0,
         1.0,
@@ -34,7 +34,7 @@ fn coords_to_ray_direction(position: vec2<f32>, viewport: vec4<f32>) -> vec3<f32
     // direction to world space. Note that the w element is set to 0.0, as this is a
     // vector direction, not a position, That causes the matrix multiplication to ignore
     // the translations from the view matrix.
-    let ray_direction = (view.view * vec4(view_ray_direction, 0.0)).xyz;
+    let ray_direction = (view.world_from_view * vec4(view_ray_direction, 0.0)).xyz;
 
     return normalize(ray_direction);
 }

crates/bevy_core_pipeline/src/skybox/skybox_prepass.wgsl

@@ -3,8 +3,8 @@
 #import bevy_pbr::view_transformations::uv_to_ndc
 
 struct PreviousViewUniforms {
-    inverse_view: mat4x4<f32>,
-    view_proj: mat4x4<f32>,
+    view_from_world: mat4x4<f32>,
+    clip_from_world: mat4x4<f32>,
 }
 
 @group(0) @binding(0) var<uniform> view: View;
@@ -13,8 +13,8 @@ struct PreviousViewUniforms {
 @fragment
 fn fragment(in: FullscreenVertexOutput) -> @location(1) vec4<f32> {
     let clip_pos = uv_to_ndc(in.uv); // Convert from uv to clip space
-    let world_pos = view.inverse_view_proj * vec4(clip_pos, 0.0, 1.0);
-    let prev_clip_pos = (previous_view.view_proj * world_pos).xy;
+    let world_pos = view.world_from_clip * vec4(clip_pos, 0.0, 1.0);
+    let prev_clip_pos = (previous_view.clip_from_world * world_pos).xy;
     let velocity = (clip_pos - prev_clip_pos) * vec2(0.5, -0.5); // Copied from mesh motion vectors
 
     return vec4(velocity.x, velocity.y, 0.0, 1.0);

crates/bevy_ecs/src/identifier/mod.rs

@@ -3,6 +3,9 @@
 //! or other IDs that can be packed and expressed within a `u64` sized type.
 //! [`Identifier`]s cannot be created directly, only able to be converted from other
 //! compatible IDs.
+#[cfg(feature = "bevy_reflect")]
+use bevy_reflect::Reflect;
+
 use self::{error::IdentifierError, kinds::IdKind, masks::IdentifierMask};
 use std::{hash::Hash, num::NonZeroU32};
 
@@ -15,6 +18,8 @@ pub(crate) mod masks;
 /// segment, a 31-bit high segment, and the significant bit reserved as type flags to denote
 /// entity kinds.
 #[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect))]
+#[cfg_attr(feature = "bevy_reflect", reflect_value(Debug, Hash, PartialEq))]
 // Alignment repr necessary to allow LLVM to better output
 // optimised codegen for `to_bits`, `PartialEq` and `Ord`.
 #[repr(C, align(8))]

crates/bevy_ecs/src/reflect/map_entities.rs

@@ -73,3 +73,34 @@ impl<C: Component + MapEntities> FromType<C> for ReflectMapEntities {
         }
     }
 }
+
+/// For a specific type of resource, this maps any fields with values of type [`Entity`] to a new world.
+/// Since a given `Entity` ID is only valid for the world it came from, when performing deserialization
+/// any stored IDs need to be re-allocated in the destination world.
+///
+/// See [`SceneEntityMapper`] and [`MapEntities`] for more information.
+#[derive(Clone)]
+pub struct ReflectMapEntitiesResource {
+    map_entities: fn(&mut World, &mut SceneEntityMapper),
+}
+
+impl ReflectMapEntitiesResource {
+    /// A method for applying [`MapEntities`] behavior to elements in an [`EntityHashMap<Entity>`].
+    pub fn map_entities(&self, world: &mut World, entity_map: &mut EntityHashMap<Entity>) {
+        SceneEntityMapper::world_scope(entity_map, world, |world, mapper| {
+            (self.map_entities)(world, mapper);
+        });
+    }
+}
+
+impl<R: crate::system::Resource + MapEntities> FromType<R> for ReflectMapEntitiesResource {
+    fn from_type() -> Self {
+        ReflectMapEntitiesResource {
+            map_entities: |world, entity_mapper| {
+                if let Some(mut resource) = world.get_resource_mut::<R>() {
+                    resource.map_entities(entity_mapper);
+                }
+            },
+        }
+    }
+}

crates/bevy_ecs/src/reflect/mod.rs

@@ -19,7 +19,7 @@ pub use bundle::{ReflectBundle, ReflectBundleFns};
 pub use component::{ReflectComponent, ReflectComponentFns};
 pub use entity_commands::ReflectCommandExt;
 pub use from_world::{ReflectFromWorld, ReflectFromWorldFns};
-pub use map_entities::ReflectMapEntities;
+pub use map_entities::{ReflectMapEntities, ReflectMapEntitiesResource};
 pub use resource::{ReflectResource, ReflectResourceFns};
 
 /// A [`Resource`] storing [`TypeRegistry`] for

crates/bevy_gizmos/src/circles.rs

@@ -178,6 +178,45 @@ where
             resolution: DEFAULT_CIRCLE_RESOLUTION,
         }
     }
+
+    /// Draw a wireframe sphere in 3D made out of 3 circles around the axes.
+    ///
+    /// This should be called for each frame the sphere needs to be rendered.
+    ///
+    /// # Example
+    /// ```
+    /// # use bevy_gizmos::prelude::*;
+    /// # use bevy_render::prelude::*;
+    /// # use bevy_math::prelude::*;
+    /// # use bevy_color::Color;
+    /// fn system(mut gizmos: Gizmos) {
+    ///     gizmos.sphere(Vec3::ZERO, Quat::IDENTITY, 1., Color::BLACK);
+    ///
+    ///     // Each circle has 32 line-segments by default.
+    ///     // You may want to increase this for larger spheres.
+    ///     gizmos
+    ///         .sphere(Vec3::ZERO, Quat::IDENTITY, 5., Color::BLACK)
+    ///         .resolution(64);
+    /// }
+    /// # bevy_ecs::system::assert_is_system(system);
+    /// ```
+    #[inline]
+    pub fn sphere(
+        &mut self,
+        position: Vec3,
+        rotation: Quat,
+        radius: f32,
+        color: impl Into<Color>,
+    ) -> SphereBuilder<'_, 'w, 's, Config, Clear> {
+        SphereBuilder {
+            gizmos: self,
+            radius,
+            position,
+            rotation,
+            color: color.into(),
+            resolution: DEFAULT_CIRCLE_RESOLUTION,
+        }
+    }
 }
 
 /// A builder returned by [`Gizmos::ellipse`].
@@ -266,3 +305,66 @@ where
         self.gizmos.linestrip_2d(positions, self.color);
     }
 }
+
+/// Builder for configuring the drawing options of [`Sphere`].
+pub struct SphereBuilder<'a, 'w, 's, Config, Clear>
+where
+    Config: GizmoConfigGroup,
+    Clear: 'static + Send + Sync,
+{
+    gizmos: &'a mut Gizmos<'w, 's, Config, Clear>,
+
+    // Radius of the sphere
+    radius: f32,
+
+    // Rotation of the sphere around the origin in 3D space
+    rotation: Quat,
+    // Center position of the sphere in 3D space
+    position: Vec3,
+    // Color of the sphere
+    color: Color,
+
+    // Number of line-segments used to approximate the sphere geometry
+    resolution: usize,
+}
+
+impl<Config, Clear> SphereBuilder<'_, '_, '_, Config, Clear>
+where
+    Config: GizmoConfigGroup,
+    Clear: 'static + Send + Sync,
+{
+    /// Set the number of line-segments used to approximate the sphere geometry.
+    pub fn resolution(mut self, resolution: usize) -> Self {
+        self.resolution = resolution;
+        self
+    }
+}
+
+impl<Config, Clear> Drop for SphereBuilder<'_, '_, '_, Config, Clear>
+where
+    Config: GizmoConfigGroup,
+    Clear: 'static + Send + Sync,
+{
+    fn drop(&mut self) {
+        if !self.gizmos.enabled {
+            return;
+        }
+
+        let SphereBuilder {
+            radius,
+            position: center,
+            rotation,
+            color,
+            resolution,
+            ..
+        } = self;
+
+        // draws one great circle around each of the local axes
+        Vec3::AXES.into_iter().for_each(|axis| {
+            let normal = *rotation * axis;
+            self.gizmos
+                .circle(*center, Dir3::new_unchecked(normal), *radius, *color)
+                .resolution(*resolution);
+        });
+    }
+}