forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix scene loading (#988)

Browse Source
This commit is contained in:
Carter Anderson 2020-12-03 13:57:36 -08:00 committed by GitHub
parent 59d98de194
commit 704a116778
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 116 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/bevy_asset/src/assets.rs
View File

@ -3,6 +3,7 @@ use crate::{
}; };
use bevy_app::{prelude::Events, AppBuilder}; use bevy_app::{prelude::Events, AppBuilder};
use bevy_ecs::{FromResources, ResMut}; use bevy_ecs::{FromResources, ResMut};
use bevy_reflect::RegisterTypeBuilder;
use bevy_utils::HashMap; use bevy_utils::HashMap;
use crossbeam_channel::Sender; use crossbeam_channel::Sender;
use std::fmt::Debug; use std::fmt::Debug;
@ -219,6 +220,7 @@ impl AddAsset for AppBuilder {
self.add_resource(assets) self.add_resource(assets)
.add_system_to_stage(super::stage::ASSET_EVENTS, Assets::<T>::asset_event_system) .add_system_to_stage(super::stage::ASSET_EVENTS, Assets::<T>::asset_event_system)
.add_system_to_stage(crate::stage::LOAD_ASSETS, update_asset_storage_system::<T>) .add_system_to_stage(crate::stage::LOAD_ASSETS, update_asset_storage_system::<T>)
.register_type::<Handle<T>>()
.add_event::<AssetEvent<T>>() .add_event::<AssetEvent<T>>()
} }

53
crates/bevy_asset/src/handle.rs
View File

@ -9,7 +9,7 @@ use crate::{
path::{AssetPath, AssetPathId}, path::{AssetPath, AssetPathId},
Asset, Assets, Asset, Assets,
}; };
use bevy_reflect::{Reflect, ReflectDeserialize}; use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
use bevy_utils::Uuid; use bevy_utils::Uuid;
use crossbeam_channel::{Receiver, Sender}; use crossbeam_channel::{Receiver, Sender};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -57,9 +57,10 @@ impl HandleId {
/// ///
/// Handles contain a unique id that corresponds to a specific asset in the [Assets](crate::Assets) collection. /// Handles contain a unique id that corresponds to a specific asset in the [Assets](crate::Assets) collection.
#[derive(Reflect)] #[derive(Reflect)]
#[reflect(Component)]
pub struct Handle<T> pub struct Handle<T>
where where
T: 'static, T: Asset,
{ {
pub id: HandleId, pub id: HandleId,
#[reflect(ignore)] #[reflect(ignore)]
@ -82,17 +83,6 @@ impl Debug for HandleType {
} }
} }
impl<T> Handle<T> {
// TODO: remove "uuid" parameter whenever rust support type constraints in const fns
pub const fn weak_from_u64(uuid: Uuid, id: u64) -> Self {
Self {
id: HandleId::new(uuid, id),
handle_type: HandleType::Weak,
marker: PhantomData,
}
}
}
impl<T: Asset> Handle<T> { impl<T: Asset> Handle<T> {
pub(crate) fn strong(id: HandleId, ref_change_sender: Sender<RefChange>) -> Self { pub(crate) fn strong(id: HandleId, ref_change_sender: Sender<RefChange>) -> Self {
ref_change_sender.send(RefChange::Increment(id)).unwrap(); ref_change_sender.send(RefChange::Increment(id)).unwrap();
@ -111,7 +101,7 @@ impl<T: Asset> Handle<T> {
} }
} }
pub fn as_weak<U>(&self) -> Handle<U> { pub fn as_weak<U: Asset>(&self) -> Handle<U> {
Handle { Handle {
id: self.id, id: self.id,
handle_type: HandleType::Weak, handle_type: HandleType::Weak,
@ -152,7 +142,7 @@ impl<T: Asset> Handle<T> {
} }
} }
impl<T> Drop for Handle<T> { impl<T: Asset> Drop for Handle<T> {
fn drop(&mut self) { fn drop(&mut self) {
match self.handle_type { match self.handle_type {
HandleType::Strong(ref sender) => { HandleType::Strong(ref sender) => {
@ -164,45 +154,51 @@ impl<T> Drop for Handle<T> {
} }
} }
impl<T> From<Handle<T>> for HandleId { impl<T: Asset> From<Handle<T>> for HandleId {
fn from(value: Handle<T>) -> Self { fn from(value: Handle<T>) -> Self {
value.id value.id
} }
} }
impl From<HandleUntyped> for HandleId {
fn from(value: HandleUntyped) -> Self {
value.id
}
}
impl From<&str> for HandleId { impl From<&str> for HandleId {
fn from(value: &str) -> Self { fn from(value: &str) -> Self {
AssetPathId::from(value).into() AssetPathId::from(value).into()
} }
} }
impl<T> From<&Handle<T>> for HandleId { impl<T: Asset> From<&Handle<T>> for HandleId {
fn from(value: &Handle<T>) -> Self { fn from(value: &Handle<T>) -> Self {
value.id value.id
} }
} }
impl<T> Hash for Handle<T> { impl<T: Asset> Hash for Handle<T> {
fn hash<H: Hasher>(&self, state: &mut H) { fn hash<H: Hasher>(&self, state: &mut H) {
Hash::hash(&self.id, state); Hash::hash(&self.id, state);
} }
} }
impl<T> PartialEq for Handle<T> { impl<T: Asset> PartialEq for Handle<T> {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
self.id == other.id self.id == other.id
} }
} }
impl<T> Eq for Handle<T> {} impl<T: Asset> Eq for Handle<T> {}
impl<T> PartialOrd for Handle<T> { impl<T: Asset> PartialOrd for Handle<T> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> { fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.id.cmp(&other.id)) Some(self.id.cmp(&other.id))
} }
} }
impl<T> Ord for Handle<T> { impl<T: Asset> Ord for Handle<T> {
fn cmp(&self, other: &Self) -> Ordering { fn cmp(&self, other: &Self) -> Ordering {
self.id.cmp(&other.id) self.id.cmp(&other.id)
} }
@ -214,7 +210,7 @@ impl<T: Asset> Default for Handle<T> {
} }
} }
impl<T> Debug for Handle<T> { impl<T: Asset> Debug for Handle<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
let name = std::any::type_name::<T>().split("::").last().unwrap(); let name = std::any::type_name::<T>().split("::").last().unwrap();
write!(f, "{:?}Handle<{}>({:?})", self.handle_type, name, self.id) write!(f, "{:?}Handle<{}>({:?})", self.handle_type, name, self.id)
@ -231,8 +227,8 @@ impl<T: Asset> Clone for Handle<T> {
} }
// SAFE: T is phantom data and Handle::id is an integer // SAFE: T is phantom data and Handle::id is an integer
unsafe impl<T> Send for Handle<T> {} unsafe impl<T: Asset> Send for Handle<T> {}
unsafe impl<T> Sync for Handle<T> {} unsafe impl<T: Asset> Sync for Handle<T> {}
/// A non-generic version of [Handle] /// A non-generic version of [Handle]
/// ///
@ -244,6 +240,13 @@ pub struct HandleUntyped {
} }
impl HandleUntyped { impl HandleUntyped {
pub const fn weak_from_u64(uuid: Uuid, id: u64) -> Self {
Self {
id: HandleId::new(uuid, id),
handle_type: HandleType::Weak,
}
}
pub(crate) fn strong(id: HandleId, ref_change_sender: Sender<RefChange>) -> Self { pub(crate) fn strong(id: HandleId, ref_change_sender: Sender<RefChange>) -> Self {
ref_change_sender.send(RefChange::Increment(id)).unwrap(); ref_change_sender.send(RefChange::Increment(id)).unwrap();
Self { Self {

10
crates/bevy_audio/src/audio.rs
View File

@ -1,17 +1,17 @@
use crate::{AudioSource, Decodable}; use crate::{AudioSource, Decodable};
use bevy_asset::Handle; use bevy_asset::{Asset, Handle};
use parking_lot::RwLock; use parking_lot::RwLock;
use std::{collections::VecDeque, fmt}; use std::{collections::VecDeque, fmt};
/// The external struct used to play audio /// The external struct used to play audio
pub struct Audio<P = AudioSource> pub struct Audio<P = AudioSource>
where where
P: Decodable, P: Asset + Decodable,
{ {
pub queue: RwLock<VecDeque<Handle<P>>>, pub queue: RwLock<VecDeque<Handle<P>>>,
} }
impl<P> fmt::Debug for Audio<P> impl<P: Asset> fmt::Debug for Audio<P>
where where
P: Decodable, P: Decodable,
{ {
@ -22,7 +22,7 @@ where
impl<P> Default for Audio<P> impl<P> Default for Audio<P>
where where
P: Decodable, P: Asset + Decodable,
{ {
fn default() -> Self { fn default() -> Self {
Self { Self {
@ -33,7 +33,7 @@ where
impl<P> Audio<P> impl<P> Audio<P>
where where
P: Decodable, P: Asset + Decodable,
<P as Decodable>::Decoder: rodio::Source + Send + Sync, <P as Decodable>::Decoder: rodio::Source + Send + Sync,
<<P as Decodable>::Decoder as Iterator>::Item: rodio::Sample + Send + Sync, <<P as Decodable>::Decoder as Iterator>::Item: rodio::Sample + Send + Sync,
{ {

3
crates/bevy_core/src/label.rs
View File

@ -1,5 +1,5 @@
use bevy_ecs::prelude::*; use bevy_ecs::prelude::*;
use bevy_reflect::Reflect; use bevy_reflect::{Reflect, ReflectComponent};
use bevy_utils::{HashMap, HashSet}; use bevy_utils::{HashMap, HashSet};
use std::{ use std::{
borrow::Cow, borrow::Cow,
@ -9,6 +9,7 @@ use std::{
/// A collection of labels /// A collection of labels
#[derive(Default, Reflect)] #[derive(Default, Reflect)]
#[reflect(Component)]
pub struct Labels { pub struct Labels {
labels: HashSet<Cow<'static, str>>, labels: HashSet<Cow<'static, str>>,
} }

2
crates/bevy_pbr/src/entity.rs
View File

@ -25,7 +25,7 @@ impl Default for PbrBundle {
fn default() -> Self { fn default() -> Self {
Self { Self {
render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new( render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
FORWARD_PIPELINE_HANDLE, FORWARD_PIPELINE_HANDLE.typed(),
)]), )]),
mesh: Default::default(), mesh: Default::default(),
material: Default::default(), material: Default::default(),

6
crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs
View File

@ -1,4 +1,4 @@
use bevy_asset::{Assets, Handle}; use bevy_asset::{Assets, HandleUntyped};
use bevy_reflect::TypeUuid; use bevy_reflect::TypeUuid;
use bevy_render::{ use bevy_render::{
pipeline::{ pipeline::{
@ -10,8 +10,8 @@ use bevy_render::{
texture::TextureFormat, texture::TextureFormat,
}; };
pub const FORWARD_PIPELINE_HANDLE: Handle<PipelineDescriptor> = pub const FORWARD_PIPELINE_HANDLE: HandleUntyped =
Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 13148362314012771389); HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 13148362314012771389);
pub(crate) fn build_forward_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor { pub(crate) fn build_forward_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
PipelineDescriptor { PipelineDescriptor {

3
crates/bevy_render/src/camera/camera.rs
View File

@ -2,10 +2,11 @@ use super::CameraProjection;
use bevy_app::prelude::{EventReader, Events}; use bevy_app::prelude::{EventReader, Events};
use bevy_ecs::{Added, Component, Entity, Local, Query, QuerySet, Res}; use bevy_ecs::{Added, Component, Entity, Local, Query, QuerySet, Res};
use bevy_math::Mat4; use bevy_math::Mat4;
use bevy_reflect::Reflect; use bevy_reflect::{Reflect, ReflectComponent};
use bevy_window::{WindowCreated, WindowId, WindowResized, Windows}; use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
#[derive(Default, Debug, Reflect)] #[derive(Default, Debug, Reflect)]
#[reflect(Component)]
pub struct Camera { pub struct Camera {
pub projection_matrix: Mat4, pub projection_matrix: Mat4,
pub name: Option<String>, pub name: Option<String>,

4
crates/bevy_render/src/camera/projection.rs
View File

@ -1,6 +1,6 @@
use super::DepthCalculation; use super::DepthCalculation;
use bevy_math::Mat4; use bevy_math::Mat4;
use bevy_reflect::{Reflect, ReflectDeserialize}; use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
pub trait CameraProjection { pub trait CameraProjection {
@ -10,6 +10,7 @@ pub trait CameraProjection {
} }
#[derive(Debug, Clone, Reflect)] #[derive(Debug, Clone, Reflect)]
#[reflect(Component)]
pub struct PerspectiveProjection { pub struct PerspectiveProjection {
pub fov: f32, pub fov: f32,
pub aspect_ratio: f32, pub aspect_ratio: f32,
@ -51,6 +52,7 @@ pub enum WindowOrigin {
} }
#[derive(Debug, Clone, Reflect)] #[derive(Debug, Clone, Reflect)]
#[reflect(Component)]
pub struct OrthographicProjection { pub struct OrthographicProjection {
pub left: f32, pub left: f32,
pub right: f32, pub right: f32,

3
crates/bevy_render/src/camera/visible_entities.rs
View File

@ -2,7 +2,7 @@ use super::{Camera, DepthCalculation};
use crate::Draw; use crate::Draw;
use bevy_core::FloatOrd; use bevy_core::FloatOrd;
use bevy_ecs::{Entity, Query, With}; use bevy_ecs::{Entity, Query, With};
use bevy_reflect::Reflect; use bevy_reflect::{Reflect, ReflectComponent};
use bevy_transform::prelude::GlobalTransform; use bevy_transform::prelude::GlobalTransform;
#[derive(Debug)] #[derive(Debug)]
@ -12,6 +12,7 @@ pub struct VisibleEntity {
} }
#[derive(Default, Debug, Reflect)] #[derive(Default, Debug, Reflect)]
#[reflect(Component)]
pub struct VisibleEntities { pub struct VisibleEntities {
#[reflect(ignore)] #[reflect(ignore)]
pub value: Vec<VisibleEntity>, pub value: Vec<VisibleEntity>,

3
crates/bevy_render/src/draw.rs
View File

@ -8,7 +8,7 @@ use crate::{
}; };
use bevy_asset::{Asset, Assets, Handle}; use bevy_asset::{Asset, Assets, Handle};
use bevy_ecs::{Query, Res, ResMut, SystemParam}; use bevy_ecs::{Query, Res, ResMut, SystemParam};
use bevy_reflect::Reflect; use bevy_reflect::{Reflect, ReflectComponent};
use std::{ops::Range, sync::Arc}; use std::{ops::Range, sync::Arc};
use thiserror::Error; use thiserror::Error;
@ -45,6 +45,7 @@ pub enum RenderCommand {
/// A component that indicates how to draw an entity. /// A component that indicates how to draw an entity.
#[derive(Debug, Clone, Reflect)] #[derive(Debug, Clone, Reflect)]
#[reflect(Component)]
pub struct Draw { pub struct Draw {
pub is_visible: bool, pub is_visible: bool,
pub is_transparent: bool, pub is_transparent: bool,

3
crates/bevy_render/src/pipeline/render_pipelines.rs
View File

@ -7,7 +7,7 @@ use crate::{
}; };
use bevy_asset::{Assets, Handle}; use bevy_asset::{Assets, Handle};
use bevy_ecs::{Query, Res, ResMut}; use bevy_ecs::{Query, Res, ResMut};
use bevy_reflect::Reflect; use bevy_reflect::{Reflect, ReflectComponent};
use bevy_utils::HashSet; use bevy_utils::HashSet;
#[derive(Debug, Default, Clone, Reflect)] #[derive(Debug, Default, Clone, Reflect)]
@ -40,6 +40,7 @@ impl RenderPipeline {
} }
#[derive(Debug, Clone, Reflect)] #[derive(Debug, Clone, Reflect)]
#[reflect(Component)]
pub struct RenderPipelines { pub struct RenderPipelines {
pub pipelines: Vec<RenderPipeline>, pub pipelines: Vec<RenderPipeline>,
#[reflect(ignore)] #[reflect(ignore)]

3
crates/bevy_render/src/render_graph/base.rs
View File

@ -10,11 +10,12 @@ use crate::{
texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage}, texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
Color, Color,
}; };
use bevy_reflect::Reflect; use bevy_reflect::{Reflect, ReflectComponent};
use bevy_window::WindowId; use bevy_window::WindowId;
/// A component that indicates that an entity should be drawn in the "main pass" /// A component that indicates that an entity should be drawn in the "main pass"
#[derive(Default, Reflect)] #[derive(Default, Reflect)]
#[reflect(Component)]
pub struct MainPass; pub struct MainPass;
#[derive(Debug)] #[derive(Debug)]

37
crates/bevy_scene/src/scene_spawner.rs
View File

@ -34,8 +34,10 @@ pub struct SceneSpawner {
#[derive(Error, Debug)] #[derive(Error, Debug)]
pub enum SceneSpawnError { pub enum SceneSpawnError {
#[error("scene contains an unregistered component")] #[error("scene contains the unregistered component `{type_name}`. consider adding `#[reflect(Component)]` to your type")]
UnregisteredComponent { type_name: String }, UnregisteredComponent { type_name: String },
#[error("scene contains the unregistered type `{type_name}`. consider registering the type using `app.register_type::<T>()`")]
UnregisteredType { type_name: String },
#[error("scene does not exist")] #[error("scene does not exist")]
NonExistentScene { handle: Handle<DynamicScene> }, NonExistentScene { handle: Handle<DynamicScene> },
#[error("scene does not exist")] #[error("scene does not exist")]
@ -118,7 +120,7 @@ impl SceneSpawner {
for component in scene_entity.components.iter() { for component in scene_entity.components.iter() {
let registration = type_registry let registration = type_registry
.get_with_name(component.type_name()) .get_with_name(component.type_name())
.ok_or_else(|| SceneSpawnError::UnregisteredComponent { .ok_or_else(|| SceneSpawnError::UnregisteredType {
type_name: component.type_name().to_string(), type_name: component.type_name().to_string(),
})?; })?;
let reflect_component = let reflect_component =
@ -166,17 +168,24 @@ impl SceneSpawner {
.entry(*scene_entity) .entry(*scene_entity)
.or_insert_with(|| world.reserve_entity()); .or_insert_with(|| world.reserve_entity());
for type_info in archetype.types() { for type_info in archetype.types() {
if let Some(registration) = type_registry.get(type_info.id()) { let registration = type_registry.get(type_info.id()).ok_or_else(|| {
if let Some(component_reflect) = registration.data::<ReflectComponent>() { SceneSpawnError::UnregisteredType {
component_reflect.copy_component( type_name: type_info.type_name().to_string(),
&scene.world,
world,
resources,
*scene_entity,
entity,
);
} }
} })?;
let reflect_component =
registration.data::<ReflectComponent>().ok_or_else(|| {
SceneSpawnError::UnregisteredComponent {
type_name: registration.name().to_string(),
}
})?;
reflect_component.copy_component(
&scene.world,
world,
resources,
*scene_entity,
entity,
);
} }
} }
} }
@ -278,7 +287,9 @@ pub fn scene_spawner_system(world: &mut World, resources: &mut Resources) {
} }
scene_spawner.despawn_queued_scenes(world).unwrap(); scene_spawner.despawn_queued_scenes(world).unwrap();
scene_spawner.spawn_queued_scenes(world, resources).unwrap(); scene_spawner
.spawn_queued_scenes(world, resources)
.unwrap_or_else(|err| panic!("{}", err));
scene_spawner scene_spawner
.update_spawned_scenes(world, resources, &updated_spawned_scenes) .update_spawned_scenes(world, resources, &updated_spawned_scenes)
.unwrap(); .unwrap();

8
crates/bevy_sprite/src/entity.rs
View File

@ -27,9 +27,9 @@ pub struct SpriteBundle {
impl Default for SpriteBundle { impl Default for SpriteBundle {
fn default() -> Self { fn default() -> Self {
Self { Self {
mesh: QUAD_HANDLE, mesh: QUAD_HANDLE.typed(),
render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new( render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
SPRITE_PIPELINE_HANDLE, SPRITE_PIPELINE_HANDLE.typed(),
)]), )]),
draw: Draw { draw: Draw {
is_transparent: true, is_transparent: true,
@ -65,13 +65,13 @@ impl Default for SpriteSheetBundle {
fn default() -> Self { fn default() -> Self {
Self { Self {
render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new( render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
SPRITE_SHEET_PIPELINE_HANDLE, SPRITE_SHEET_PIPELINE_HANDLE.typed(),
)]), )]),
draw: Draw { draw: Draw {
is_transparent: true, is_transparent: true,
..Default::default() ..Default::default()
}, },
mesh: QUAD_HANDLE, mesh: QUAD_HANDLE.typed(),
main_pass: MainPass, main_pass: MainPass,
sprite: Default::default(), sprite: Default::default(),
texture_atlas: Default::default(), texture_atlas: Default::default(),

5
crates/bevy_sprite/src/lib.rs
View File

@ -25,7 +25,7 @@ pub mod prelude {
} }
use bevy_app::prelude::*; use bevy_app::prelude::*;
use bevy_asset::{AddAsset, Assets, Handle}; use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
use bevy_math::Vec2; use bevy_math::Vec2;
use bevy_reflect::{RegisterTypeBuilder, TypeUuid}; use bevy_reflect::{RegisterTypeBuilder, TypeUuid};
use bevy_render::{ use bevy_render::{
@ -38,7 +38,8 @@ use sprite::sprite_system;
#[derive(Default)] #[derive(Default)]
pub struct SpritePlugin; pub struct SpritePlugin;
pub const QUAD_HANDLE: Handle<Mesh> = Handle::weak_from_u64(Mesh::TYPE_UUID, 14240461981130137526); pub const QUAD_HANDLE: HandleUntyped =
HandleUntyped::weak_from_u64(Mesh::TYPE_UUID, 14240461981130137526);
impl Plugin for SpritePlugin { impl Plugin for SpritePlugin {
fn build(&self, app: &mut AppBuilder) { fn build(&self, app: &mut AppBuilder) {

10
crates/bevy_sprite/src/render/mod.rs
View File

@ -1,5 +1,5 @@
use crate::{ColorMaterial, Sprite, TextureAtlas, TextureAtlasSprite}; use crate::{ColorMaterial, Sprite, TextureAtlas, TextureAtlasSprite};
use bevy_asset::{Assets, Handle}; use bevy_asset::{Assets, HandleUntyped};
use bevy_ecs::Resources; use bevy_ecs::Resources;
use bevy_reflect::TypeUuid; use bevy_reflect::TypeUuid;
use bevy_render::{ use bevy_render::{
@ -13,11 +13,11 @@ use bevy_render::{
texture::TextureFormat, texture::TextureFormat,
}; };
pub const SPRITE_PIPELINE_HANDLE: Handle<PipelineDescriptor> = pub const SPRITE_PIPELINE_HANDLE: HandleUntyped =
Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 2785347840338765446); HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 2785347840338765446);
pub const SPRITE_SHEET_PIPELINE_HANDLE: Handle<PipelineDescriptor> = pub const SPRITE_SHEET_PIPELINE_HANDLE: HandleUntyped =
Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 9016885805180281612); HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 9016885805180281612);
pub fn build_sprite_sheet_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor { pub fn build_sprite_sheet_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
PipelineDescriptor { PipelineDescriptor {

13
crates/bevy_text/src/draw.rs
View File

@ -3,6 +3,7 @@ use bevy_render::{
color::Color, color::Color,
draw::{Draw, DrawContext, DrawError, Drawable}, draw::{Draw, DrawContext, DrawError, Drawable},
mesh, mesh,
mesh::Mesh,
pipeline::{PipelineSpecialization, VertexBufferDescriptor}, pipeline::{PipelineSpecialization, VertexBufferDescriptor},
prelude::Msaa, prelude::Msaa,
renderer::{BindGroup, RenderResourceBindings, RenderResourceId}, renderer::{BindGroup, RenderResourceBindings, RenderResourceId},
@ -57,7 +58,7 @@ impl<'a> Drawable for DrawableText<'a> {
fn draw(&mut self, draw: &mut Draw, context: &mut DrawContext) -> Result<(), DrawError> { fn draw(&mut self, draw: &mut Draw, context: &mut DrawContext) -> Result<(), DrawError> {
context.set_pipeline( context.set_pipeline(
draw, draw,
&bevy_sprite::SPRITE_SHEET_PIPELINE_HANDLE, &bevy_sprite::SPRITE_SHEET_PIPELINE_HANDLE.typed(),
&PipelineSpecialization { &PipelineSpecialization {
sample_count: self.msaa.samples, sample_count: self.msaa.samples,
vertex_buffer_descriptor: self.font_quad_vertex_descriptor.clone(), vertex_buffer_descriptor: self.font_quad_vertex_descriptor.clone(),
@ -68,7 +69,10 @@ impl<'a> Drawable for DrawableText<'a> {
let render_resource_context = &**context.render_resource_context; let render_resource_context = &**context.render_resource_context;
if let Some(RenderResourceId::Buffer(vertex_attribute_buffer_id)) = render_resource_context if let Some(RenderResourceId::Buffer(vertex_attribute_buffer_id)) = render_resource_context
.get_asset_resource(&bevy_sprite::QUAD_HANDLE, mesh::VERTEX_ATTRIBUTE_BUFFER_ID) .get_asset_resource(
&bevy_sprite::QUAD_HANDLE.typed::<Mesh>(),
mesh::VERTEX_ATTRIBUTE_BUFFER_ID,
)
{ {
draw.set_vertex_buffer(0, vertex_attribute_buffer_id, 0); draw.set_vertex_buffer(0, vertex_attribute_buffer_id, 0);
} else { } else {
@ -77,7 +81,10 @@ impl<'a> Drawable for DrawableText<'a> {
let mut indices = 0..0; let mut indices = 0..0;
if let Some(RenderResourceId::Buffer(quad_index_buffer)) = render_resource_context if let Some(RenderResourceId::Buffer(quad_index_buffer)) = render_resource_context
.get_asset_resource(&bevy_sprite::QUAD_HANDLE, mesh::INDEX_BUFFER_ASSET_INDEX) .get_asset_resource(
&bevy_sprite::QUAD_HANDLE.typed::<Mesh>(),
mesh::INDEX_BUFFER_ASSET_INDEX,
)
{ {
draw.set_index_buffer(quad_index_buffer, 0); draw.set_index_buffer(quad_index_buffer, 0);
if let Some(buffer_info) = render_resource_context.get_buffer_info(quad_index_buffer) { if let Some(buffer_info) = render_resource_context.get_buffer_info(quad_index_buffer) {

4
crates/bevy_transform/src/components/children.rs
View File

@ -1,10 +1,10 @@
use bevy_ecs::{Entity, MapEntities}; use bevy_ecs::{Entity, MapEntities};
use bevy_reflect::{Reflect, ReflectMapEntities}; use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities};
use smallvec::SmallVec; use smallvec::SmallVec;
use std::ops::Deref; use std::ops::Deref;
#[derive(Default, Clone, Debug, Reflect)] #[derive(Default, Clone, Debug, Reflect)]
#[reflect(MapEntities)] #[reflect(Component, MapEntities)]
pub struct Children(pub(crate) SmallVec<[Entity; 8]>); pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
impl MapEntities for Children { impl MapEntities for Children {

3
crates/bevy_transform/src/components/global_transform.rs
View File

@ -1,9 +1,10 @@
use super::Transform; use super::Transform;
use bevy_math::{Mat3, Mat4, Quat, Vec3}; use bevy_math::{Mat3, Mat4, Quat, Vec3};
use bevy_reflect::Reflect; use bevy_reflect::{Reflect, ReflectComponent};
use std::ops::Mul; use std::ops::Mul;
#[derive(Debug, PartialEq, Clone, Copy, Reflect)] #[derive(Debug, PartialEq, Clone, Copy, Reflect)]
#[reflect(Component)]
pub struct GlobalTransform { pub struct GlobalTransform {
pub translation: Vec3, pub translation: Vec3,
pub rotation: Quat, pub rotation: Quat,

6
crates/bevy_transform/src/components/parent.rs
View File

@ -1,9 +1,9 @@
use bevy_ecs::{Entity, FromResources, MapEntities}; use bevy_ecs::{Entity, FromResources, MapEntities};
use bevy_reflect::{Reflect, ReflectMapEntities}; use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities};
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)] #[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
#[reflect(MapEntities)] #[reflect(Component, MapEntities)]
pub struct Parent(pub Entity); pub struct Parent(pub Entity);
// TODO: We need to impl either FromResources or Default so Parent can be registered as Properties. // TODO: We need to impl either FromResources or Default so Parent can be registered as Properties.
@ -41,7 +41,7 @@ impl DerefMut for Parent {
} }
#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)] #[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
#[reflect(MapEntities)] #[reflect(Component, MapEntities)]
pub struct PreviousParent(pub(crate) Entity); pub struct PreviousParent(pub(crate) Entity);
impl MapEntities for PreviousParent { impl MapEntities for PreviousParent {

12
crates/bevy_ui/src/entity.rs
View File

@ -31,9 +31,9 @@ pub struct NodeBundle {
impl Default for NodeBundle { impl Default for NodeBundle {
fn default() -> Self { fn default() -> Self {
NodeBundle { NodeBundle {
mesh: QUAD_HANDLE, mesh: QUAD_HANDLE.typed(),
render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new( render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
UI_PIPELINE_HANDLE, UI_PIPELINE_HANDLE.typed(),
)]), )]),
node: Default::default(), node: Default::default(),
style: Default::default(), style: Default::default(),
@ -62,9 +62,9 @@ pub struct ImageBundle {
impl Default for ImageBundle { impl Default for ImageBundle {
fn default() -> Self { fn default() -> Self {
ImageBundle { ImageBundle {
mesh: QUAD_HANDLE, mesh: QUAD_HANDLE.typed(),
render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new( render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
UI_PIPELINE_HANDLE, UI_PIPELINE_HANDLE.typed(),
)]), )]),
node: Default::default(), node: Default::default(),
image: Default::default(), image: Default::default(),
@ -127,9 +127,9 @@ impl Default for ButtonBundle {
fn default() -> Self { fn default() -> Self {
ButtonBundle { ButtonBundle {
button: Button, button: Button,
mesh: QUAD_HANDLE, mesh: QUAD_HANDLE.typed(),
render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new( render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
UI_PIPELINE_HANDLE, UI_PIPELINE_HANDLE.typed(),
)]), )]),
interaction: Default::default(), interaction: Default::default(),
focus_policy: Default::default(), focus_policy: Default::default(),

6
crates/bevy_ui/src/render/mod.rs
View File

@ -1,5 +1,5 @@
use crate::Node; use crate::Node;
use bevy_asset::{Assets, Handle}; use bevy_asset::{Assets, HandleUntyped};
use bevy_ecs::Resources; use bevy_ecs::Resources;
use bevy_reflect::TypeUuid; use bevy_reflect::TypeUuid;
use bevy_render::{ use bevy_render::{
@ -18,8 +18,8 @@ use bevy_render::{
texture::TextureFormat, texture::TextureFormat,
}; };
pub const UI_PIPELINE_HANDLE: Handle<PipelineDescriptor> = pub const UI_PIPELINE_HANDLE: HandleUntyped =
Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 3234320022263993878); HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 3234320022263993878);
pub fn build_ui_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor { pub fn build_ui_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
PipelineDescriptor { PipelineDescriptor {