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

render: simplify imports and cleanup prelude

Browse Source
This commit is contained in:
Carter Anderson 2020-07-16 18:26:21 -07:00
parent 196bde64e3
commit b12c4d0a48
84 changed files with 249 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
crates/bevy_core/src/lib.rs
View File

@ -1,12 +1,15 @@
pub mod bytes;
pub mod float_ord;
pub mod time;
mod bytes;
mod float_ord;
mod time;
pub use bytes::*;
pub use float_ord::*;
pub use time::*;
use bevy_app::{stage, AppBuilder, AppPlugin};
use bevy_ecs::IntoQuerySystem;
use bevy_math::{Mat3, Mat4, Quat, Vec2, Vec3};
use bevy_type_registry::RegisterType;
use time::{time_system, timer_system, Time, Timer};
#[derive(Default)]
pub struct CorePlugin;

2
crates/bevy_derive/src/bytes.rs
View File

@ -27,7 +27,7 @@ pub fn derive_bytes(input: TokenStream) -> TokenStream {
let struct_name = &ast.ident;
TokenStream::from(quote! {
impl #impl_generics #bevy_core_path::bytes::Bytes for #struct_name#ty_generics {
impl #impl_generics #bevy_core_path::Bytes for #struct_name#ty_generics {
fn write_bytes(&self, buffer: &mut [u8]) {
let mut offset: usize = 0;
#(let byte_len = self.#fields.byte_len();

10
crates/bevy_derive/src/render_resource.rs
View File

@ -13,16 +13,16 @@ pub fn derive_render_resource(input: TokenStream) -> TokenStream {
let struct_name = &ast.ident;
TokenStream::from(quote! {
impl #bevy_render_path::render_resource::RenderResource for #struct_name {
fn resource_type(&self) -> Option<#bevy_render_path::render_resource::RenderResourceType> {
Some(#bevy_render_path::render_resource::RenderResourceType::Buffer)
impl #bevy_render_path::renderer::RenderResource for #struct_name {
fn resource_type(&self) -> Option<#bevy_render_path::renderer::RenderResourceType> {
Some(#bevy_render_path::renderer::RenderResourceType::Buffer)
}
fn write_buffer_bytes(&self, buffer: &mut [u8]) {
use #bevy_core_path::bytes::Bytes;
use #bevy_core_path::Bytes;
self.write_bytes(buffer);
}
fn buffer_byte_len(&self) -> Option<usize> {
use #bevy_core_path::bytes::Bytes;
use #bevy_core_path::Bytes;
Some(self.byte_len())
}
fn texture(&self) -> Option<#bevy_asset_path::Handle<#bevy_render_path::texture::Texture>> {

25
crates/bevy_derive/src/render_resources.rs
View File

@ -50,12 +50,12 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
if attributes.from_self {
TokenStream::from(quote! {
impl #bevy_render_path::render_resource::RenderResources for #struct_name {
impl #bevy_render_path::renderer::RenderResources for #struct_name {
fn render_resources_len(&self) -> usize {
1
}
fn get_render_resource(&self, index: usize) -> Option<&dyn #bevy_render_path::render_resource::RenderResource> {
fn get_render_resource(&self, index: usize) -> Option<&dyn #bevy_render_path::renderer::RenderResource> {
if index == 0 {
Some(self)
} else {
@ -71,8 +71,8 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
}
}
fn iter_render_resources(&self) -> #bevy_render_path::render_resource::RenderResourceIterator {
#bevy_render_path::render_resource::RenderResourceIterator::new(self)
fn iter_render_resources(&self) -> #bevy_render_path::renderer::RenderResourceIterator {
#bevy_render_path::renderer::RenderResourceIterator::new(self)
}
}
})
@ -131,9 +131,8 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
render_resource_fields.push(field_ident);
render_resource_names.push(format!("{}_{}", struct_name, field_name));
if attrs.buffer {
render_resource_hints.push(
quote! {Some(#bevy_render_path::render_resource::RenderResourceHints::BUFFER)},
)
render_resource_hints
.push(quote! {Some(#bevy_render_path::renderer::RenderResourceHints::BUFFER)})
} else {
render_resource_hints.push(quote! {None})
}
@ -153,16 +152,16 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
#(#render_resource_names,)*
];
static #render_resource_hints_ident: &[Option<#bevy_render_path::render_resource::RenderResourceHints>] = &[
static #render_resource_hints_ident: &[Option<#bevy_render_path::renderer::RenderResourceHints>] = &[
#(#render_resource_hints,)*
];
impl #bevy_render_path::render_resource::RenderResources for #struct_name {
impl #bevy_render_path::renderer::RenderResources for #struct_name {
fn render_resources_len(&self) -> usize {
#render_resource_count
}
fn get_render_resource(&self, index: usize) -> Option<&dyn #bevy_render_path::render_resource::RenderResource> {
fn get_render_resource(&self, index: usize) -> Option<&dyn #bevy_render_path::renderer::RenderResource> {
match index {
#(#render_resource_indices => Some(&self.#render_resource_fields),)*
_ => None,
@ -173,12 +172,12 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
Some(#render_resource_names_ident[index])
}
fn get_render_resource_hints(&self, index: usize) -> Option<#bevy_render_path::render_resource::RenderResourceHints> {
fn get_render_resource_hints(&self, index: usize) -> Option<#bevy_render_path::renderer::RenderResourceHints> {
#render_resource_hints_ident[index].clone()
}
fn iter_render_resources(&self) -> #bevy_render_path::render_resource::RenderResourceIterator {
#bevy_render_path::render_resource::RenderResourceIterator::new(self)
fn iter_render_resources(&self) -> #bevy_render_path::renderer::RenderResourceIterator {
#bevy_render_path::renderer::RenderResourceIterator::new(self)
}
}
})

2
crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
View File

@ -1,6 +1,6 @@
use crate::{Diagnostic, DiagnosticId, Diagnostics};
use bevy_app::AppPlugin;
use bevy_core::time::Time;
use bevy_core::Time;
use bevy_ecs::{IntoQuerySystem, Res, ResMut};
#[derive(Default)]

2
crates/bevy_diagnostic/src/print_diagnostics_plugin.rs
View File

@ -1,6 +1,6 @@
use super::{Diagnostic, DiagnosticId, Diagnostics};
use bevy_app::{stage, AppPlugin};
use bevy_core::time::{Time, Timer};
use bevy_core::{Time, Timer};
use bevy_ecs::{IntoQuerySystem, Res, ResMut};
use std::time::Duration;

4
crates/bevy_ecs/src/lib.rs
View File

@ -5,7 +5,7 @@ mod into_system;
mod parallel_executor;
#[cfg(feature = "profiler")]
pub mod profiler;
pub mod resource_query;
mod resource_query;
mod resources;
mod schedule;
mod system;
@ -14,7 +14,7 @@ mod world_builder;
pub use commands::{Commands, CommandsInternal};
pub use into_system::{IntoForEachSystem, IntoQuerySystem, IntoThreadLocalSystem, Query};
pub use parallel_executor::ParallelExecutor;
pub use resource_query::{FetchResource, Local, Res, ResMut, ResourceQuery};
pub use resource_query::{FetchResource, Local, Res, ResMut, ResourceQuery, UnsafeClone};
pub use resources::{FromResources, Resource, Resources};
pub use schedule::Schedule;
pub use system::{ArchetypeAccess, System, SystemId, TypeAccess};

2
crates/bevy_gltf/src/loader.rs
View File

@ -1,6 +1,6 @@
use bevy_render::{
mesh::{Mesh, VertexAttribute, VertexAttributeValues},
pipeline::state_descriptors::PrimitiveTopology,
pipeline::PrimitiveTopology,
};
use anyhow::Result;

12
crates/bevy_pbr/src/forward_pbr_render_graph.rs
View File

@ -6,12 +6,8 @@ use crate::{
use bevy_asset::Assets;
use bevy_ecs::Resources;
use bevy_render::{
base_render_graph,
pipeline::PipelineDescriptor,
render_graph::{
nodes::{AssetRenderResourcesNode, RenderResourcesNode},
RenderGraph,
},
render_graph::{base, AssetRenderResourcesNode, RenderGraph, RenderResourcesNode},
shader::Shader,
};
use bevy_transform::prelude::Transform;
@ -46,11 +42,11 @@ impl ForwardPbrRenderGraphBuilder for RenderGraph {
);
// TODO: replace these with "autowire" groups
self.add_node_edge(node::STANDARD_MATERIAL, base_render_graph::node::MAIN_PASS)
self.add_node_edge(node::STANDARD_MATERIAL, base::node::MAIN_PASS)
.unwrap();
self.add_node_edge(node::TRANSFORM, base_render_graph::node::MAIN_PASS)
self.add_node_edge(node::TRANSFORM, base::node::MAIN_PASS)
.unwrap();
self.add_node_edge(node::LIGHTS, base_render_graph::node::MAIN_PASS)
self.add_node_edge(node::LIGHTS, base::node::MAIN_PASS)
.unwrap();
self
}

7
crates/bevy_pbr/src/light.rs
View File

@ -1,7 +1,10 @@
use bevy_core::bytes::Byteable;
use bevy_core::Byteable;
use bevy_math::Mat4;
use bevy_property::Properties;
use bevy_render::{CameraProjection, Color, PerspectiveProjection};
use bevy_render::{
camera::{CameraProjection, PerspectiveProjection},
color::Color,
};
use bevy_transform::components::Translation;
use std::ops::Range;

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

@ -1,5 +1,5 @@
use bevy_asset::{self, Handle};
use bevy_render::{render_resource::RenderResources, shader::ShaderDefs, texture::Texture, Color};
use bevy_render::{color::Color, renderer::RenderResources, shader::ShaderDefs, texture::Texture};
#[derive(RenderResources, ShaderDefs)]
pub struct StandardMaterial {

17
crates/bevy_pbr/src/nodes/lights_node.rs
View File

@ -1,17 +1,16 @@
use bevy_render::{
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{
BufferId, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings,
},
renderer::{RenderContext, RenderResourceContext},
};
use crate::{
light::{Light, LightRaw},
uniform,
};
use bevy_core::bytes::{AsBytes, Byteable};
use bevy_core::{AsBytes, Byteable};
use bevy_ecs::{Commands, IntoQuerySystem, Local, Query, Res, ResMut, Resources, System, World};
use bevy_render::{
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
renderer::{
BufferId, BufferInfo, BufferUsage, RenderContext, RenderResourceBinding,
RenderResourceBindings, RenderResourceContext,
},
};
use bevy_transform::prelude::*;
#[derive(Default)]

5
crates/bevy_pbr/src/pipelines/forward/mod.rs
View File

@ -1,13 +1,10 @@
use bevy_asset::{Assets, Handle};
use bevy_render::{
pipeline::{
state_descriptors::{
BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace,
CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, PipelineDescriptor,
RasterizationStateDescriptor, StencilStateFaceDescriptor,
},
PipelineDescriptor,
},
shader::{Shader, ShaderStage, ShaderStages},
texture::TextureFormat,
};

2
crates/bevy_render/src/camera/active_cameras.rs
View File

@ -1,4 +1,4 @@
use crate::Camera;
use super::Camera;
use bevy_ecs::{Entity, Query, ResMut};
use std::collections::HashMap;

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

@ -1,4 +1,4 @@
use crate::CameraProjection;
use super::CameraProjection;
use bevy_app::{EventReader, Events};
use bevy_ecs::{Component, Local, Query, Res};
use bevy_math::Mat4;

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

@ -1,5 +1,6 @@
use crate::{draw::Draw, Camera};
use bevy_core::float_ord::FloatOrd;
use super::Camera;
use crate::Draw;
use bevy_core::FloatOrd;
use bevy_ecs::{Entity, Query};
use bevy_transform::prelude::Transform;

4
crates/bevy_render/src/color.rs
View File

@ -1,10 +1,10 @@
use super::texture::Texture;
use crate::{
impl_render_resource_bytes,
render_resource::{RenderResource, RenderResourceType},
renderer::{RenderResource, RenderResourceType},
};
use bevy_asset::Handle;
use bevy_core::bytes::{Byteable, Bytes};
use bevy_core::{Byteable, Bytes};
use bevy_math::Vec4;
use bevy_property::Property;
use serde::{Deserialize, Serialize};

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

@ -3,17 +3,16 @@ use crate::{
PipelineCompiler, PipelineDescriptor, PipelineLayout, PipelineSpecialization,
VertexBufferDescriptors,
},
render_resource::{
renderer::{
BindGroup, BindGroupId, BufferId, BufferUsage, RenderResource, RenderResourceBinding,
RenderResourceBindings, SharedBuffers,
RenderResourceBindings, RenderResourceContext, SharedBuffers,
},
renderer::RenderResourceContext,
shader::Shader,
};
use bevy_asset::{Assets, Handle};
use bevy_ecs::{
resource_query::UnsafeClone, Archetype, FetchResource, Query, Res, ResMut, ResourceQuery,
Resources, SystemId, TypeAccess,
Archetype, FetchResource, Query, Res, ResMut, ResourceQuery, Resources, SystemId, TypeAccess,
UnsafeClone,
};
use bevy_property::Properties;
use std::{any::TypeId, collections::HashMap, ops::Range, sync::Arc};

10
crates/bevy_render/src/entity.rs
View File

@ -1,6 +1,8 @@
use crate::{
base_render_graph, draw::Draw, mesh::Mesh, pipeline::RenderPipelines, Camera,
OrthographicProjection, PerspectiveProjection, VisibleEntities,
camera::{Camera, OrthographicProjection, PerspectiveProjection, VisibleEntities},
pipeline::RenderPipelines,
render_graph::base,
Draw, Mesh,
};
use bevy_asset::Handle;
use bevy_ecs::Bundle;
@ -32,7 +34,7 @@ impl Default for PerspectiveCameraComponents {
fn default() -> Self {
PerspectiveCameraComponents {
camera: Camera {
name: Some(base_render_graph::camera::CAMERA3D.to_string()),
name: Some(base::camera::CAMERA3D.to_string()),
..Default::default()
},
perspective_projection: Default::default(),
@ -60,7 +62,7 @@ impl Default for OrthographicCameraComponents {
fn default() -> Self {
OrthographicCameraComponents {
camera: Camera {
name: Some(base_render_graph::camera::CAMERA2D.to_string()),
name: Some(base::camera::CAMERA2D.to_string()),
..Default::default()
},
orthographic_projection: Default::default(),

69
crates/bevy_render/src/lib.rs
View File

@ -1,47 +1,38 @@
pub mod batch;
mod camera;
pub mod camera;
pub mod color;
pub mod draw;
pub mod entity;
pub mod mesh;
pub mod pass;
pub mod pipeline;
pub mod render_graph;
pub mod renderer;
pub mod shader;
pub mod texture;
pub mod vertex;
mod color;
pub use camera::*;
pub use color::*;
pub use vertex::Vertex;
pub mod base_render_graph;
pub mod pass;
pub mod pipeline;
pub mod render_resource;
pub mod texture;
mod entity;
pub use once_cell;
use self::{
mesh::Mesh,
pipeline::{PipelineCompiler, PipelineDescriptor, VertexBufferDescriptors},
render_resource::RenderResourceBindings,
shader::Shader,
pub mod prelude {
pub use crate::{
color::Color, draw::Draw, entity::*, mesh::Mesh, pipeline::RenderPipelines, shader::Shader,
texture::Texture,
};
};
}
use base_render_graph::{BaseRenderGraphBuilder, BaseRenderGraphConfig};
use crate::prelude::*;
use bevy_app::{AppBuilder, AppPlugin};
use bevy_asset::AddAsset;
use bevy_ecs::{IntoQuerySystem, IntoThreadLocalSystem};
use bevy_type_registry::RegisterType;
use draw::{clear_draw_system, Draw};
use mesh::mesh_resource_provider_system;
use pipeline::{draw_render_pipelines_system, RenderPipelines};
use render_graph::{system::render_graph_schedule_executor_system, RenderGraph};
use render_resource::AssetRenderResourceBindings;
use shader::clear_shader_defs_system;
use camera::{ActiveCameras, Camera, OrthographicProjection, PerspectiveProjection};
use pipeline::{PipelineCompiler, PipelineDescriptor, VertexBufferDescriptors};
use render_graph::{
base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig},
RenderGraph,
};
use renderer::{AssetRenderResourceBindings, RenderResourceBindings};
use std::ops::Range;
use texture::{PngTextureLoader, TextureResourceSystemState};
@ -95,7 +86,10 @@ impl AppPlugin for RenderPlugin {
.init_resource::<TextureResourceSystemState>()
.init_resource::<AssetRenderResourceBindings>()
.init_resource::<ActiveCameras>()
.add_system_to_stage(bevy_app::stage::PRE_UPDATE, clear_draw_system.system())
.add_system_to_stage(
bevy_app::stage::PRE_UPDATE,
draw::clear_draw_system.system(),
)
.add_system_to_stage(
bevy_app::stage::POST_UPDATE,
camera::active_cameras_system.system(),
@ -111,12 +105,12 @@ impl AppPlugin for RenderPlugin {
// registration order matters here. this must come after all camera_system::<T> systems
.add_system_to_stage(
bevy_app::stage::POST_UPDATE,
visible_entities_system.system(),
camera::visible_entities_system.system(),
)
// TODO: turn these "resource systems" into graph nodes and remove the RENDER_RESOURCE stage
.add_system_to_stage(
stage::RENDER_RESOURCE,
mesh_resource_provider_system.system(),
mesh::mesh_resource_provider_system.system(),
)
.add_system_to_stage(
stage::RENDER_RESOURCE,
@ -124,10 +118,13 @@ impl AppPlugin for RenderPlugin {
)
.add_system_to_stage(
stage::RENDER_GRAPH_SYSTEMS,
render_graph_schedule_executor_system.thread_local_system(),
render_graph::render_graph_schedule_executor_system.thread_local_system(),
)
.add_system_to_stage(stage::DRAW, draw_render_pipelines_system.system())
.add_system_to_stage(stage::POST_RENDER, clear_shader_defs_system.system());
.add_system_to_stage(stage::DRAW, pipeline::draw_render_pipelines_system.system())
.add_system_to_stage(
stage::POST_RENDER,
shader::clear_shader_defs_system.system(),
);
if let Some(ref config) = self.base_render_graph_config {
let resources = app.resources();
@ -135,11 +132,11 @@ impl AppPlugin for RenderPlugin {
render_graph.add_base_graph(config);
let mut active_cameras = resources.get_mut::<ActiveCameras>().unwrap();
if config.add_3d_camera {
active_cameras.add(base_render_graph::camera::CAMERA3D);
active_cameras.add(base::camera::CAMERA3D);
}
if config.add_2d_camera {
active_cameras.add(base_render_graph::camera::CAMERA2D);
active_cameras.add(base::camera::CAMERA2D);
}
}
}

17
crates/bevy_render/src/mesh.rs
View File

@ -1,15 +1,14 @@
use crate::{
pipeline::{
state_descriptors::{IndexFormat, PrimitiveTopology},
AsVertexBufferDescriptor, VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
AsVertexBufferDescriptor, IndexFormat, PrimitiveTopology, RenderPipelines,
VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
},
render_resource::{BufferInfo, BufferUsage, RenderResourceId},
renderer::RenderResourceContext,
RenderPipelines, Vertex,
renderer::{BufferInfo, BufferUsage, RenderResourceContext, RenderResourceId},
vertex::Vertex,
};
use bevy_app::{EventReader, Events};
use bevy_asset::{AssetEvent, Assets, Handle};
use bevy_core::bytes::AsBytes;
use bevy_core::AsBytes;
use bevy_ecs::{Local, Query, Res, ResMut};
use bevy_math::*;
use std::{borrow::Cow, collections::HashSet};
@ -168,7 +167,7 @@ impl Mesh {
pub mod shape {
use super::{Mesh, VertexAttribute};
use crate::pipeline::state_descriptors::PrimitiveTopology;
use crate::pipeline::PrimitiveTopology;
use bevy_math::*;
pub struct Cube {
@ -510,8 +509,8 @@ pub fn mesh_resource_provider_system(
#[cfg(test)]
mod tests {
use super::{AsVertexBufferDescriptor, Mesh, VertexAttribute};
use crate::{pipeline::state_descriptors::PrimitiveTopology, Vertex};
use bevy_core::bytes::AsBytes;
use crate::{pipeline::PrimitiveTopology, vertex::Vertex};
use bevy_core::AsBytes;
#[test]
fn test_get_vertex_bytes() {

2
crates/bevy_render/src/pass/pass.rs
View File

@ -1,5 +1,5 @@
use super::Operations;
use crate::{render_resource::TextureId, Color};
use crate::{renderer::TextureId, Color};
#[derive(Debug, Clone)]
pub enum TextureAttachment {

3
crates/bevy_render/src/pass/render_pass.rs
View File

@ -1,7 +1,6 @@
use crate::{
pipeline::{BindGroupDescriptorId, PipelineDescriptor},
render_resource::{BindGroupId, BufferId},
renderer::RenderContext,
renderer::{BindGroupId, BufferId, RenderContext},
};
use bevy_asset::Handle;
use std::ops::Range;

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

@ -4,7 +4,7 @@ mod pipeline;
mod pipeline_compiler;
mod pipeline_layout;
mod render_pipelines;
pub mod state_descriptors;
mod state_descriptors;
mod vertex_buffer_descriptor;
mod vertex_format;
@ -14,5 +14,6 @@ pub use pipeline::*;
pub use pipeline_compiler::*;
pub use pipeline_layout::*;
pub use render_pipelines::*;
pub use state_descriptors::*;
pub use vertex_buffer_descriptor::*;
pub use vertex_format::*;

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

@ -1,7 +1,7 @@
use super::{PipelineDescriptor, PipelineSpecialization};
use crate::{
draw::{Draw, DrawContext, DrawError, Drawable},
render_resource::RenderResourceBindings,
renderer::RenderResourceBindings,
};
use bevy_asset::Handle;
use bevy_ecs::{Query, ResMut};

11
crates/bevy_render/src/base_render_graph/mod.rs → crates/bevy_render/src/render_graph/base.rs
View File

@ -1,15 +1,12 @@
use super::{
CameraNode, PassNode, RenderGraph, SharedBuffersNode, TextureCopyNode, WindowSwapChainNode,
WindowTextureNode,
};
use crate::{
pass::{
LoadOp, Operations, PassDescriptor, RenderPassColorAttachmentDescriptor,
RenderPassDepthStencilAttachmentDescriptor, TextureAttachment,
},
render_graph::{
nodes::{
CameraNode, PassNode, SharedBuffersNode, TextureCopyNode, WindowSwapChainNode,
WindowTextureNode,
},
RenderGraph,
},
texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
Color,
};

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

@ -1,6 +1,5 @@
use crate::{
render_resource::{BufferId, TextureId},
renderer::RenderContext,
renderer::{BufferId, RenderContext, TextureId},
texture::Extent3d,
};
use std::sync::{Arc, Mutex};

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

@ -297,8 +297,7 @@ mod tests {
use super::RenderGraph;
use crate::{
render_graph::{Edge, Node, NodeId, RenderGraphError, ResourceSlotInfo, ResourceSlots},
render_resource::RenderResourceType,
renderer::RenderContext,
renderer::{RenderContext, RenderResourceType},
};
use bevy_ecs::{Resources, World};
use std::{collections::HashSet, iter::FromIterator};

8
crates/bevy_render/src/render_graph/mod.rs
View File

@ -1,17 +1,21 @@
pub mod base;
mod command;
mod edge;
mod graph;
mod node;
mod node_slot;
pub mod nodes;
mod nodes;
mod schedule;
pub mod system;
mod system;
pub use command::*;
pub use edge::*;
pub use graph::*;
pub use node::*;
pub use node_slot::*;
pub use nodes::*;
pub use schedule::*;
pub use system::*;
use thiserror::Error;

2
crates/bevy_render/src/render_graph/node_slot.rs
View File

@ -1,5 +1,5 @@
use super::RenderGraphError;
use crate::render_resource::{RenderResourceId, RenderResourceType};
use crate::renderer::{RenderResourceId, RenderResourceType};
use std::borrow::Cow;
#[derive(Debug, Clone)]

10
crates/bevy_render/src/render_graph/nodes/camera_node.rs
View File

@ -1,12 +1,12 @@
use crate::{
camera::{ActiveCameras, Camera},
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{
BufferId, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings,
renderer::{
BufferId, BufferInfo, BufferUsage, RenderContext, RenderResourceBinding,
RenderResourceBindings, RenderResourceContext,
},
renderer::{RenderContext, RenderResourceContext},
ActiveCameras, Camera,
};
use bevy_core::bytes::AsBytes;
use bevy_core::AsBytes;
use bevy_ecs::{Commands, IntoQuerySystem, Local, Query, Res, ResMut, Resources, System, World};
use bevy_transform::prelude::*;

7
crates/bevy_render/src/render_graph/nodes/pass_node.rs
View File

@ -1,15 +1,14 @@
use crate::{
camera::{ActiveCameras, VisibleEntities},
draw::{Draw, RenderCommand},
pass::{ClearColor, LoadOp, PassDescriptor, TextureAttachment},
pipeline::{
BindGroupDescriptor, BindType, BindingDescriptor, PipelineDescriptor, UniformProperty,
},
render_graph::{Node, ResourceSlotInfo, ResourceSlots},
render_resource::{
BindGroup, BindGroupId, BufferId, RenderResourceBindings, RenderResourceType,
renderer::{
BindGroup, BindGroupId, BufferId, RenderContext, RenderResourceBindings, RenderResourceType,
},
renderer::RenderContext,
ActiveCameras, VisibleEntities,
};
use bevy_asset::{Assets, Handle};
use bevy_ecs::{Resources, World};

34
crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
View File

@ -2,17 +2,17 @@ use crate::{
draw::Draw,
pipeline::RenderPipelines,
render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
render_resource::{
self, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings,
RenderResourceBindingsId, RenderResourceHints,
renderer::{
self, BufferInfo, BufferUsage, RenderContext, RenderResourceBinding,
RenderResourceBindings, RenderResourceBindingsId, RenderResourceContext,
RenderResourceHints,
},
renderer::{RenderContext, RenderResourceContext},
texture,
};
use bevy_asset::{Assets, Handle};
use bevy_ecs::{Commands, IntoQuerySystem, Local, Query, Res, ResMut, Resources, System, World};
use render_resource::{AssetRenderResourceBindings, BufferId, RenderResourceType, RenderResources};
use renderer::{AssetRenderResourceBindings, BufferId, RenderResourceType, RenderResources};
use std::{collections::HashMap, marker::PhantomData, ops::DerefMut};
pub const BIND_BUFFER_ALIGNMENT: usize = 256;
@ -60,7 +60,7 @@ impl BufferArrayStatus {
struct UniformBufferArrays<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
uniform_arrays: Vec<Option<(String, BufferArrayStatus)>>,
staging_buffer: Option<BufferId>,
@ -70,7 +70,7 @@ where
impl<T> Default for UniformBufferArrays<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
fn default() -> Self {
Self {
@ -84,7 +84,7 @@ where
impl<T> UniformBufferArrays<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
fn reset_changed_item_counts(&mut self) {
for buffer_status in self.uniform_arrays.iter_mut() {
@ -342,7 +342,7 @@ where
#[derive(Default)]
pub struct RenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
command_queue: CommandQueue,
dynamic_uniforms: bool,
@ -351,7 +351,7 @@ where
impl<T> RenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
pub fn new(dynamic_uniforms: bool) -> Self {
RenderResourcesNode {
@ -364,7 +364,7 @@ where
impl<T> Node for RenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
fn update(
&mut self,
@ -380,7 +380,7 @@ where
impl<T> SystemNode for RenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
fn get_system(&self, commands: &mut Commands) -> Box<dyn System> {
let system = render_resources_node_system::<T>.system();
@ -498,7 +498,7 @@ fn render_resources_node_system<T: RenderResources>(
#[derive(Default)]
pub struct AssetRenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
command_queue: CommandQueue,
dynamic_uniforms: bool,
@ -507,7 +507,7 @@ where
impl<T> AssetRenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
pub fn new(dynamic_uniforms: bool) -> Self {
AssetRenderResourcesNode {
@ -520,7 +520,7 @@ where
impl<T> Node for AssetRenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
fn update(
&mut self,
@ -538,7 +538,7 @@ const EXPECT_ASSET_MESSAGE: &str = "Only assets that exist should be in the modi
impl<T> SystemNode for AssetRenderResourcesNode<T>
where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
fn get_system(&self, commands: &mut Commands) -> Box<dyn System> {
let system = asset_render_resources_node_system::<T>.system();
@ -669,7 +669,7 @@ fn setup_uniform_texture_resources<T>(
render_resource_context: &dyn RenderResourceContext,
render_resource_bindings: &mut RenderResourceBindings,
) where
T: render_resource::RenderResources,
T: renderer::RenderResources,
{
for (i, render_resource) in uniforms.iter_render_resources().enumerate() {
if let Some(RenderResourceType::Texture) = render_resource.resource_type() {

3
crates/bevy_render/src/render_graph/nodes/shared_buffers_node.rs
View File

@ -1,7 +1,6 @@
use crate::{
render_graph::{Node, ResourceSlots},
render_resource::SharedBuffers,
renderer::RenderContext,
renderer::{RenderContext, SharedBuffers},
};
use bevy_ecs::{Resources, World};

3
crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
View File

@ -1,7 +1,6 @@
use crate::{
render_graph::{Node, ResourceSlots},
render_resource::{BufferInfo, BufferUsage},
renderer::RenderContext,
renderer::{BufferInfo, BufferUsage, RenderContext},
texture::{Texture, TextureDescriptor, TEXTURE_ASSET_INDEX},
};
use bevy_app::{EventReader, Events};

3
crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
View File

@ -1,7 +1,6 @@
use crate::{
render_graph::{Node, ResourceSlotInfo, ResourceSlots},
render_resource::{RenderResourceId, RenderResourceType},
renderer::RenderContext,
renderer::{RenderContext, RenderResourceId, RenderResourceType},
};
use bevy_app::{EventReader, Events};
use bevy_ecs::{Resources, World};

3
crates/bevy_render/src/render_graph/nodes/window_texture_node.rs
View File

@ -1,7 +1,6 @@
use crate::{
render_graph::{Node, ResourceSlotInfo, ResourceSlots},
render_resource::{RenderResourceId, RenderResourceType},
renderer::RenderContext,
renderer::{RenderContext, RenderResourceId, RenderResourceType},
texture::TextureDescriptor,
};
use bevy_app::{EventReader, Events};

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

@ -264,8 +264,7 @@ mod tests {
use super::{DependentNodeStager, OrderedJob, RenderGraphStager, Stage};
use crate::{
render_graph::{Node, NodeId, RenderGraph, ResourceSlotInfo, ResourceSlots},
render_resource::RenderResourceType,
renderer::RenderContext,
renderer::{RenderContext, RenderResourceType},
};
use bevy_ecs::{Resources, World};

2
crates/bevy_render/src/renderer/headless_render_resource_context.rs
View File

@ -1,7 +1,7 @@
use super::RenderResourceContext;
use crate::{
pipeline::{BindGroupDescriptorId, PipelineDescriptor},
render_resource::{BindGroup, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
renderer::{BindGroup, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
shader::Shader,
texture::{SamplerDescriptor, TextureDescriptor},
};

2
crates/bevy_render/src/renderer/mod.rs
View File

@ -1,7 +1,9 @@
mod headless_render_resource_context;
mod render_context;
mod render_resource;
mod render_resource_context;
pub use headless_render_resource_context::*;
pub use render_context::*;
pub use render_resource::*;
pub use render_resource_context::*;

2
crates/bevy_render/src/renderer/render_context.rs
View File

@ -1,7 +1,7 @@
use super::RenderResourceContext;
use crate::{
pass::{PassDescriptor, RenderPass},
render_resource::{BufferId, RenderResourceBindings, TextureId},
renderer::{BufferId, RenderResourceBindings, TextureId},
texture::Extent3d,
};

0
crates/bevy_render/src/render_resource/bind_group.rs → crates/bevy_render/src/renderer/render_resource/bind_group.rs
View File

0
crates/bevy_render/src/render_resource/buffer.rs → crates/bevy_render/src/renderer/render_resource/buffer.rs
View File

0
crates/bevy_render/src/render_resource/mod.rs → crates/bevy_render/src/renderer/render_resource/mod.rs
View File

2
crates/bevy_render/src/render_resource/render_resource.rs → crates/bevy_render/src/renderer/render_resource/render_resource.rs
View File

@ -2,7 +2,7 @@ use super::{BufferId, SamplerId, TextureId};
use crate::texture::Texture;
use bevy_asset::Handle;
use bevy_core::bytes::{Byteable, Bytes};
use bevy_core::{Byteable, Bytes};
pub use bevy_derive::{RenderResource, RenderResources};
use bevy_math::{Mat4, Vec2, Vec3, Vec4};

0
crates/bevy_render/src/render_resource/render_resource_bindings.rs → crates/bevy_render/src/renderer/render_resource/render_resource_bindings.rs
View File

3
crates/bevy_render/src/render_resource/shared_buffers.rs → crates/bevy_render/src/renderer/render_resource/shared_buffers.rs
View File

@ -1,6 +1,7 @@
use super::{BufferId, BufferInfo, RenderResource, RenderResourceBinding};
use crate::{
render_graph::CommandQueue, render_resource::BufferUsage, renderer::RenderResourceContext,
render_graph::CommandQueue,
renderer::{BufferUsage, RenderResourceContext},
};
use bevy_ecs::Res;
use std::sync::{Arc, RwLock};

0
crates/bevy_render/src/render_resource/texture.rs → crates/bevy_render/src/renderer/render_resource/texture.rs
View File

2
crates/bevy_render/src/renderer/render_resource_context.rs
View File

@ -1,6 +1,6 @@
use crate::{
pipeline::{BindGroupDescriptorId, PipelineDescriptor},
render_resource::{BindGroup, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
renderer::{BindGroup, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
shader::Shader,
texture::{SamplerDescriptor, TextureDescriptor},
};

2
crates/bevy_render/src/shader/shader_defs.rs
View File

@ -1,6 +1,6 @@
use crate::{texture::Texture, RenderPipelines};
use bevy_asset::{Assets, Handle};
use crate::{pipeline::RenderPipelines, Texture};
pub use bevy_derive::ShaderDefs;
use bevy_ecs::{Query, Res};

2
crates/bevy_render/src/shader/shader_reflect.rs
View File

@ -5,7 +5,7 @@ use crate::{
},
texture::{TextureComponentType, TextureViewDimension},
};
use bevy_core::bytes::AsBytes;
use bevy_core::AsBytes;
use spirv_reflect::{
types::{
ReflectDescriptorBinding, ReflectDescriptorSet, ReflectDescriptorType, ReflectDimension,

2
crates/bevy_render/src/texture/sampler_descriptor.rs
View File

@ -1,5 +1,5 @@
use super::Texture;
use crate::pipeline::state_descriptors::CompareFunction;
use crate::pipeline::CompareFunction;
#[derive(Copy, Clone)]
pub struct SamplerDescriptor {

5
crates/bevy_render/src/texture/texture.rs
View File

@ -1,7 +1,6 @@
use super::{SamplerDescriptor, TextureDescriptor};
use crate::{
render_resource::{RenderResource, RenderResourceId, RenderResourceType},
renderer::RenderResourceContext,
use crate::renderer::{
RenderResource, RenderResourceContext, RenderResourceId, RenderResourceType,
};
use bevy_app::{EventReader, Events};
use bevy_asset::{AssetEvent, Assets, Handle};

2
crates/bevy_render/src/vertex.rs
View File

@ -1,5 +1,5 @@
use crate::pipeline::AsVertexBufferDescriptor;
use bevy_core::bytes::Byteable;
use bevy_core::Byteable;
#[repr(C)]
#[derive(Clone, Copy, AsVertexBufferDescriptor)]

2
crates/bevy_sprite/src/color_material.rs
View File

@ -1,5 +1,5 @@
use bevy_asset::{self, Handle};
use bevy_render::{render_resource::RenderResources, shader::ShaderDefs, texture::Texture, Color};
use bevy_render::{color::Color, renderer::RenderResources, shader::ShaderDefs, texture::Texture};
#[derive(RenderResources, ShaderDefs)]
pub struct ColorMaterial {

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

@ -5,9 +5,9 @@ use crate::{
use bevy_asset::Handle;
use bevy_ecs::Bundle;
use bevy_render::{
draw::Draw,
mesh::Mesh,
pipeline::{DynamicBinding, PipelineSpecialization, RenderPipeline, RenderPipelines},
prelude::Draw,
};
use bevy_transform::prelude::{Rotation, Scale, Transform, Translation};

2
crates/bevy_sprite/src/rect.rs
View File

@ -1,4 +1,4 @@
use bevy_core::bytes::Byteable;
use bevy_core::Byteable;
use bevy_math::Vec2;
/// A rectangle defined by two points. There is no defined origin, so 0,0 could be anywhere (top-left, bottom-left, etc)

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

@ -2,12 +2,12 @@ use crate::{ColorMaterial, Sprite, TextureAtlas, TextureAtlasSprite};
use bevy_asset::{Assets, Handle};
use bevy_ecs::Resources;
use bevy_render::{
base_render_graph,
pipeline::{state_descriptors::*, PipelineDescriptor},
render_graph::{
nodes::{AssetRenderResourcesNode, RenderResourcesNode},
RenderGraph,
pipeline::{
BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, PipelineDescriptor,
RasterizationStateDescriptor, StencilStateFaceDescriptor,
},
render_graph::{base, AssetRenderResourcesNode, RenderGraph, RenderResourcesNode},
shader::{Shader, ShaderStage, ShaderStages},
texture::TextureFormat,
};
@ -125,11 +125,11 @@ impl SpriteRenderGraphBuilder for RenderGraph {
node::COLOR_MATERIAL,
AssetRenderResourcesNode::<ColorMaterial>::new(false),
);
self.add_node_edge(node::COLOR_MATERIAL, base_render_graph::node::MAIN_PASS)
self.add_node_edge(node::COLOR_MATERIAL, base::node::MAIN_PASS)
.unwrap();
self.add_system_node(node::SPRITE, RenderResourcesNode::<Sprite>::new(true));
self.add_node_edge(node::SPRITE, base_render_graph::node::MAIN_PASS)
self.add_node_edge(node::SPRITE, base::node::MAIN_PASS)
.unwrap();
self.add_system_node(

4
crates/bevy_sprite/src/sprite.rs
View File

@ -1,10 +1,10 @@
use crate::ColorMaterial;
use bevy_asset::{Assets, Handle};
use bevy_core::bytes::Byteable;
use bevy_core::Byteable;
use bevy_ecs::{Query, Res};
use bevy_math::Vec2;
use bevy_render::{
render_resource::{RenderResource, RenderResources},
renderer::{RenderResource, RenderResources},
texture::Texture,
};

6
crates/bevy_sprite/src/texture_atlas.rs
View File

@ -1,11 +1,11 @@
use crate::Rect;
use bevy_asset::Handle;
use bevy_core::bytes::Bytes;
use bevy_core::Bytes;
use bevy_math::Vec2;
use bevy_render::{
render_resource::{RenderResource, RenderResources},
color::Color,
renderer::{RenderResource, RenderResources},
texture::Texture,
Color,
};
use std::collections::HashMap;

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

@ -3,14 +3,14 @@ use ab_glyph::{Glyph, PxScale, ScaleFont};
use bevy_asset::Assets;
use bevy_math::{Mat4, Vec3};
use bevy_render::{
color::Color,
draw::{Draw, DrawContext, DrawError, Drawable},
mesh,
pipeline::PipelineSpecialization,
render_resource::{
renderer::{
AssetRenderResourceBindings, BindGroup, BufferUsage, RenderResourceBindings,
RenderResourceId,
},
Color,
};
use bevy_sprite::{TextureAtlas, TextureAtlasSprite};

2
crates/bevy_text/src/font.rs
View File

@ -1,6 +1,6 @@
use ab_glyph::{FontVec, Glyph, InvalidFont, OutlinedGlyph, Point, PxScale, ScaleFont};
use bevy_math::Vec2;
use bevy_render::{texture::Texture, Color};
use bevy_render::{color::Color, texture::Texture};
pub struct Font {
pub font: FontVec,

2
crates/bevy_text/src/font_atlas_set.rs
View File

@ -1,7 +1,7 @@
use crate::{Font, FontAtlas};
use ab_glyph::ScaleFont;
use bevy_asset::{Assets, Handle};
use bevy_core::float_ord::FloatOrd;
use bevy_core::FloatOrd;
use bevy_math::Vec2;
use bevy_render::texture::Texture;
use bevy_sprite::TextureAtlas;

2
crates/bevy_ui/src/node.rs
View File

@ -1,6 +1,6 @@
use super::{Anchors, Margins};
use bevy_math::{Vec2, Vec3};
use bevy_render::render_resource::RenderResources;
use bevy_render::renderer::RenderResources;
use bevy_transform::prelude::Translation;
#[derive(Debug, Clone)]

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

@ -2,15 +2,11 @@ use crate::Node;
use bevy_asset::{Assets, Handle};
use bevy_ecs::Resources;
use bevy_render::{
base_render_graph,
pipeline::{state_descriptors::*, PipelineDescriptor},
render_graph::{
nodes::{CameraNode, PassNode, RenderResourcesNode},
RenderGraph,
},
camera::ActiveCameras,
pipeline::*,
render_graph::{base, CameraNode, PassNode, RenderGraph, RenderResourcesNode},
shader::{Shader, ShaderStage, ShaderStages},
texture::TextureFormat,
ActiveCameras,
};
pub const UI_PIPELINE_HANDLE: Handle<PipelineDescriptor> =
@ -82,15 +78,13 @@ impl UiRenderGraphBuilder for RenderGraph {
// setup ui camera
self.add_system_node(node::UI_CAMERA, CameraNode::new(camera::UI_CAMERA));
self.add_node_edge(node::UI_CAMERA, base_render_graph::node::MAIN_PASS)
self.add_node_edge(node::UI_CAMERA, base::node::MAIN_PASS)
.unwrap();
self.add_system_node(node::NODE, RenderResourcesNode::<Node>::new(true));
self.add_node_edge(node::NODE, base_render_graph::node::MAIN_PASS)
self.add_node_edge(node::NODE, base::node::MAIN_PASS)
.unwrap();
let mut active_cameras = resources.get_mut::<ActiveCameras>().unwrap();
let main_pass_node: &mut PassNode = self
.get_node_mut(base_render_graph::node::MAIN_PASS)
.unwrap();
let main_pass_node: &mut PassNode = self.get_node_mut(base::node::MAIN_PASS).unwrap();
main_pass_node.add_camera(camera::UI_CAMERA);
active_cameras.add(camera::UI_CAMERA);
self

4
crates/bevy_ui/src/widget/label.rs
View File

@ -2,10 +2,10 @@ use crate::Node;
use bevy_asset::{Assets, Handle};
use bevy_ecs::{Query, Res, ResMut};
use bevy_render::{
color::Color,
draw::{Draw, DrawContext, Drawable},
render_resource::{AssetRenderResourceBindings, RenderResourceBindings},
renderer::{AssetRenderResourceBindings, RenderResourceBindings},
texture::Texture,
Color,
};
use bevy_sprite::TextureAtlas;
use bevy_text::{DrawableText, Font, FontAtlasSet, TextStyle};

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

@ -11,10 +11,7 @@ pub use wgpu_resources::*;
use bevy_app::{AppBuilder, AppPlugin};
use bevy_ecs::{IntoQuerySystem, IntoThreadLocalSystem, Resources, World};
use bevy_render::{
render_resource::{free_shared_buffers_system, SharedBuffers},
renderer::RenderResourceContext,
};
use bevy_render::renderer::{free_shared_buffers_system, RenderResourceContext, SharedBuffers};
use renderer::WgpuRenderResourceContext;
#[derive(Default)]

6
crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
View File

@ -6,8 +6,10 @@ use bevy_render::{
PassDescriptor, RenderPass, RenderPassColorAttachmentDescriptor,
RenderPassDepthStencilAttachmentDescriptor, TextureAttachment,
},
render_resource::{BufferId, RenderResourceBinding, RenderResourceBindings, TextureId},
renderer::{RenderContext, RenderResourceContext},
renderer::{
BufferId, RenderContext, RenderResourceBinding, RenderResourceBindings,
RenderResourceContext, TextureId,
},
texture::Extent3d,
};

7
crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
View File

@ -6,11 +6,10 @@ use crate::{
use bevy_asset::{Assets, Handle, HandleUntyped};
use bevy_render::{
pipeline::{BindGroupDescriptor, BindGroupDescriptorId, PipelineDescriptor},
render_resource::{
BindGroup, BufferId, BufferInfo, RenderResourceBinding, RenderResourceId, SamplerId,
TextureId,
renderer::{
BindGroup, BufferId, BufferInfo, RenderResourceBinding, RenderResourceContext,
RenderResourceId, SamplerId, TextureId,
},
renderer::RenderResourceContext,
shader::Shader,
texture::{Extent3d, SamplerDescriptor, TextureDescriptor},
};

3
crates/bevy_wgpu/src/wgpu_render_pass.rs
View File

@ -3,8 +3,7 @@ use bevy_asset::Handle;
use bevy_render::{
pass::RenderPass,
pipeline::{BindGroupDescriptorId, PipelineDescriptor},
render_resource::{BindGroupId, BufferId},
renderer::RenderContext,
renderer::{BindGroupId, BufferId, RenderContext},
};
use std::ops::Range;

2
crates/bevy_wgpu/src/wgpu_resources.rs
View File

@ -1,7 +1,7 @@
use bevy_asset::{Handle, HandleUntyped};
use bevy_render::{
pipeline::{BindGroupDescriptorId, PipelineDescriptor},
render_resource::{BindGroupId, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
renderer::{BindGroupId, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
shader::Shader,
texture::TextureDescriptor,
};

14
crates/bevy_wgpu/src/wgpu_type_converter.rs
View File

@ -1,20 +1,18 @@
use bevy_render::{
color::Color,
pass::{LoadOp, Operations},
pipeline::{
state_descriptors::{
BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
BindType, BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, IndexFormat,
PrimitiveTopology, RasterizationStateDescriptor, StencilOperation,
StencilStateFaceDescriptor,
InputStepMode, PrimitiveTopology, RasterizationStateDescriptor, StencilOperation,
StencilStateFaceDescriptor, VertexAttributeDescriptor, VertexBufferDescriptor,
VertexFormat,
},
BindType, InputStepMode, VertexAttributeDescriptor, VertexBufferDescriptor, VertexFormat,
},
render_resource::BufferUsage,
renderer::BufferUsage,
texture::{
AddressMode, Extent3d, FilterMode, SamplerDescriptor, TextureComponentType,
TextureDescriptor, TextureDimension, TextureFormat, TextureUsage, TextureViewDimension,
},
Color,
};
use bevy_window::Window;

2
examples/3d/3d_scene.rs
View File

@ -1,4 +1,4 @@
use bevy::prelude::*;
use bevy::{prelude::*, render::mesh::shape};
fn main() {
App::build()

2
examples/3d/parenting.rs
View File

@ -1,4 +1,4 @@
use bevy::prelude::*;
use bevy::{prelude::*, render::mesh::shape};
struct Rotator;

1
examples/3d/spawner.rs
View File

@ -1,6 +1,7 @@
use bevy::{
diagnostic::{FrameTimeDiagnosticsPlugin, PrintDiagnosticsPlugin},
prelude::*,
render::mesh::shape,
};
use rand::{rngs::StdRng, Rng, SeedableRng};

2
examples/3d/texture.rs
View File

@ -1,4 +1,4 @@
use bevy::prelude::*;
use bevy::{prelude::*, render::mesh::shape};
fn main() {
App::build()

8
examples/3d/z_sort_debug.rs
View File

@ -1,4 +1,10 @@
use bevy::prelude::*;
use bevy::{
prelude::*,
render::{
camera::{Camera, VisibleEntities},
mesh::shape,
},
};
struct Rotator;

2
examples/app/dynamic_plugin_loading/example_plugin/src/lib.rs
View File

@ -1,4 +1,4 @@
use bevy::prelude::*;
use bevy::{prelude::*, render::mesh::shape};
#[derive(DynamicAppPlugin)]
pub struct ExamplePlugin;

1
examples/game/breakout.rs
View File

@ -1,5 +1,6 @@
use bevy::{
prelude::*,
render::pass::ClearColor,
sprite::collide_aabb::{collide, Collision},
};

9
examples/shader/shader_custom_material.rs
View File

@ -1,8 +1,11 @@
use bevy::{
prelude::*,
render::{
base_render_graph,
pipeline::{DynamicBinding, PipelineSpecialization, RenderPipeline},
mesh::shape,
pipeline::{DynamicBinding, PipelineDescriptor, PipelineSpecialization, RenderPipeline},
render_graph::{base, AssetRenderResourcesNode, RenderGraph},
renderer::RenderResources,
shader::{ShaderStage, ShaderStages},
},
};
@ -66,7 +69,7 @@ fn setup(
// Add a Render Graph edge connecting our new "my_material" node to the main pass node
render_graph
.add_node_edge("my_material", base_render_graph::node::MAIN_PASS)
.add_node_edge("my_material", base::node::MAIN_PASS)
.unwrap();
// Create a new material

12
examples/shader/shader_defs.rs
View File

@ -1,9 +1,11 @@
use bevy::{
prelude::*,
render::{
base_render_graph,
pipeline::{DynamicBinding, PipelineSpecialization, RenderPipeline},
shader,
mesh::shape,
pipeline::{DynamicBinding, PipelineDescriptor, PipelineSpecialization, RenderPipeline},
render_graph::{base, AssetRenderResourcesNode, RenderGraph},
renderer::RenderResources,
shader::{asset_shader_defs_system, ShaderDefs, ShaderStage, ShaderStages},
},
};
@ -14,7 +16,7 @@ fn main() {
.add_startup_system(setup.system())
.add_system_to_stage(
stage::POST_UPDATE,
shader::asset_shader_defs_system::<MyMaterial>.system(),
asset_shader_defs_system::<MyMaterial>.system(),
)
.run();
}
@ -78,7 +80,7 @@ fn setup(
// Add a Render Graph edge connecting our new "my_material" node to the main pass node
render_graph
.add_node_edge("my_material", base_render_graph::node::MAIN_PASS)
.add_node_edge("my_material", base::node::MAIN_PASS)
.unwrap();
// Create a green material

2
examples/window/clear_color.rs
View File

@ -1,4 +1,4 @@
use bevy::prelude::*;
use bevy::{prelude::*, render::pass::ClearColor};
fn main() {
App::build()

8
examples/window/multiple_windows.rs
View File

@ -1,12 +1,10 @@
use bevy::{
prelude::*,
render::{
pass::{
LoadOp, Operations, PassDescriptor, RenderPassColorAttachmentDescriptor,
RenderPassDepthStencilAttachmentDescriptor, TextureAttachment,
},
camera::{ActiveCameras, Camera},
pass::*,
render_graph::{CameraNode, PassNode, RenderGraph, WindowSwapChainNode, WindowTextureNode},
texture::{TextureDescriptor, TextureFormat, TextureUsage},
ActiveCameras,
},
window::{CreateWindow, WindowId, WindowReference},
};

21
src/prelude.rs
View File

@ -5,7 +5,7 @@ pub use crate::{
},
asset::{AddAsset, AssetEvent, AssetServer, Assets, Handle},
audio::{AudioOutput, AudioSource},
core::time::{Time, Timer},
core::{Time, Timer},
diagnostic::DiagnosticsPlugin,
ecs::{
Bundle, Commands, Component, Entity, FromResources, IntoForEachSystem, IntoQuerySystem,
@ -16,24 +16,7 @@ pub use crate::{
math::{self, FaceToward, Mat3, Mat4, Quat, Vec2, Vec3, Vec4},
pbr::{entity::*, light::Light, material::StandardMaterial},
property::{DynamicProperties, Properties, PropertiesVal, Property, PropertyVal},
render::{
draw::Draw,
entity::*,
mesh::{shape, Mesh},
pass::ClearColor,
pipeline::{PipelineDescriptor, RenderPipelines},
render_graph::{
nodes::{
AssetRenderResourcesNode, CameraNode, PassNode, RenderResourcesNode,
WindowSwapChainNode, WindowTextureNode,
},
RenderGraph,
},
render_resource::RenderResources,
shader::{Shader, ShaderDefs, ShaderStage, ShaderStages},
texture::Texture,
Camera, Color, ColorSource, OrthographicProjection, PerspectiveProjection, VisibleEntities,
},
render::prelude::*,
scene::{Scene, SceneSpawner},
sprite::{
entity::{SpriteComponents, SpriteSheetComponents},