render: simplify imports and cleanup prelude

crates/bevy_core/src/lib.rs

@@ -1,12 +1,15 @@
-pub mod bytes;
+mod bytes;
-pub mod float_ord;
+mod float_ord;
-pub mod time;
+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;

crates/bevy_derive/src/bytes.rs

@@ -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();

crates/bevy_derive/src/render_resource.rs

@@ -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 {
+        impl #bevy_render_path::renderer::RenderResource for #struct_name {
-            fn resource_type(&self) -> Option<#bevy_render_path::render_resource::RenderResourceType> {
+            fn resource_type(&self) -> Option<#bevy_render_path::renderer::RenderResourceType> {
-                Some(#bevy_render_path::render_resource::RenderResourceType::Buffer)
+                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>> {

crates/bevy_derive/src/render_resources.rs

@@ -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 {
+                fn iter_render_resources(&self) -> #bevy_render_path::renderer::RenderResourceIterator {
-                    #bevy_render_path::render_resource::RenderResourceIterator::new(self)
+                    #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(
+                render_resource_hints
-                    quote! {Some(#bevy_render_path::render_resource::RenderResourceHints::BUFFER)},
+                    .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 {
+                fn iter_render_resources(&self) -> #bevy_render_path::renderer::RenderResourceIterator {
-                    #bevy_render_path::render_resource::RenderResourceIterator::new(self)
+                    #bevy_render_path::renderer::RenderResourceIterator::new(self)
                 }
             }
         })

crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs

@@ -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)]

crates/bevy_diagnostic/src/print_diagnostics_plugin.rs

@@ -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;
 

crates/bevy_ecs/src/lib.rs

@@ -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};

crates/bevy_gltf/src/loader.rs

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

crates/bevy_pbr/src/forward_pbr_render_graph.rs

@@ -6,12 +6,8 @@ use crate::{
 use bevy_asset::Assets;
 use bevy_ecs::Resources;
 use bevy_render::{
-    base_render_graph,
     pipeline::PipelineDescriptor,
-    render_graph::{
+    render_graph::{base, AssetRenderResourcesNode, RenderGraph, RenderResourcesNode},
-        nodes::{AssetRenderResourcesNode, RenderResourcesNode},
-        RenderGraph,
-    },
     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
     }

crates/bevy_pbr/src/light.rs

@@ -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;
 

crates/bevy_pbr/src/material.rs

@@ -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 {

crates/bevy_pbr/src/nodes/lights_node.rs

@@ -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)]

crates/bevy_pbr/src/pipelines/forward/mod.rs

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

crates/bevy_render/src/camera/active_cameras.rs

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

crates/bevy_render/src/camera/camera.rs

@@ -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;

crates/bevy_render/src/camera/visible_entities.rs

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

crates/bevy_render/src/color.rs

@@ -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};

crates/bevy_render/src/draw.rs

@@ -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,
+    Archetype, FetchResource, Query, Res, ResMut, ResourceQuery, Resources, SystemId, TypeAccess,
-    Resources, SystemId, TypeAccess,
+    UnsafeClone,
 };
 use bevy_property::Properties;
 use std::{any::TypeId, collections::HashMap, ops::Range, sync::Arc};

crates/bevy_render/src/entity.rs

@@ -1,6 +1,8 @@
 use crate::{
-    base_render_graph, draw::Draw, mesh::Mesh, pipeline::RenderPipelines, Camera,
+    camera::{Camera, OrthographicProjection, PerspectiveProjection, VisibleEntities},
-    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(),

crates/bevy_render/src/lib.rs

@@ -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;
+mod entity;
-
-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;
-
 pub use once_cell;
 
-use self::{
+pub mod prelude {
-    mesh::Mesh,
+    pub use crate::{
-    pipeline::{PipelineCompiler, PipelineDescriptor, VertexBufferDescriptors},
+        color::Color, draw::Draw, entity::*, mesh::Mesh, pipeline::RenderPipelines, shader::Shader,
-    render_resource::RenderResourceBindings,
+        texture::Texture,
-    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 camera::{ActiveCameras, Camera, OrthographicProjection, PerspectiveProjection};
-use mesh::mesh_resource_provider_system;
+use pipeline::{PipelineCompiler, PipelineDescriptor, VertexBufferDescriptors};
-use pipeline::{draw_render_pipelines_system, RenderPipelines};
+use render_graph::{
-use render_graph::{system::render_graph_schedule_executor_system, RenderGraph};
+    base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig},
-use render_resource::AssetRenderResourceBindings;
+    RenderGraph,
-use shader::clear_shader_defs_system;
+};
+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::DRAW, pipeline::draw_render_pipelines_system.system())
-            .add_system_to_stage(stage::POST_RENDER, clear_shader_defs_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);
             }
         }
     }

crates/bevy_render/src/mesh.rs

@@ -1,15 +1,14 @@
 use crate::{
     pipeline::{
-        state_descriptors::{IndexFormat, PrimitiveTopology},
+        AsVertexBufferDescriptor, IndexFormat, PrimitiveTopology, RenderPipelines,
-        AsVertexBufferDescriptor, VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
+        VertexBufferDescriptor, VertexBufferDescriptors, VertexFormat,
     },
-    render_resource::{BufferInfo, BufferUsage, RenderResourceId},
+    renderer::{BufferInfo, BufferUsage, RenderResourceContext, RenderResourceId},
-    renderer::RenderResourceContext,
+    vertex::Vertex,
-    RenderPipelines, 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 crate::{pipeline::PrimitiveTopology, vertex::Vertex};
-    use bevy_core::bytes::AsBytes;
+    use bevy_core::AsBytes;
 
     #[test]
     fn test_get_vertex_bytes() {

crates/bevy_render/src/pass/pass.rs

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

crates/bevy_render/src/pass/render_pass.rs

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

crates/bevy_render/src/pipeline/mod.rs

@@ -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::*;

crates/bevy_render/src/pipeline/render_pipelines.rs

@@ -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};

crates/bevy_render/src/render_graph/base.rs

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

crates/bevy_render/src/render_graph/command.rs

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

crates/bevy_render/src/render_graph/graph.rs

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

crates/bevy_render/src/render_graph/mod.rs

@@ -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;
 

crates/bevy_render/src/render_graph/node_slot.rs

@@ -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)]

crates/bevy_render/src/render_graph/nodes/camera_node.rs

@@ -1,12 +1,12 @@
 use crate::{
+    camera::{ActiveCameras, Camera},
     render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
-    render_resource::{
+    renderer::{
-        BufferId, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings,
+        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::*;

crates/bevy_render/src/render_graph/nodes/pass_node.rs

@@ -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::{
+    renderer::{
-        BindGroup, BindGroupId, BufferId, RenderResourceBindings, RenderResourceType,
+        BindGroup, BindGroupId, BufferId, RenderContext, RenderResourceBindings, RenderResourceType,
     },
-    renderer::RenderContext,
-    ActiveCameras, VisibleEntities,
 };
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{Resources, World};

crates/bevy_render/src/render_graph/nodes/render_resources_node.rs

@@ -2,17 +2,17 @@ use crate::{
     draw::Draw,
     pipeline::RenderPipelines,
     render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
-    render_resource::{
+    renderer::{
-        self, BufferInfo, BufferUsage, RenderResourceBinding, RenderResourceBindings,
+        self, BufferInfo, BufferUsage, RenderContext, RenderResourceBinding,
-        RenderResourceBindingsId, RenderResourceHints,
+        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() {

crates/bevy_render/src/render_graph/nodes/shared_buffers_node.rs

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

crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs

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

crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs

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

crates/bevy_render/src/render_graph/nodes/window_texture_node.rs

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

crates/bevy_render/src/render_graph/schedule.rs

@@ -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, RenderResourceType},
-        renderer::RenderContext,
     };
     use bevy_ecs::{Resources, World};
 

crates/bevy_render/src/renderer/headless_render_resource_context.rs

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

crates/bevy_render/src/renderer/mod.rs

@@ -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::*;

crates/bevy_render/src/renderer/render_context.rs

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

crates/bevy_render/src/renderer/render_resource/render_resource.rs

@@ -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};
 

crates/bevy_render/src/renderer/render_resource/shared_buffers.rs

@@ -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};

crates/bevy_render/src/renderer/render_resource_context.rs

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

crates/bevy_render/src/shader/shader_defs.rs

@@ -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};
 

crates/bevy_render/src/shader/shader_reflect.rs

@@ -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,

crates/bevy_render/src/texture/sampler_descriptor.rs

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

crates/bevy_render/src/texture/texture.rs

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

crates/bevy_render/src/vertex.rs

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

crates/bevy_sprite/src/color_material.rs

@@ -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 {

crates/bevy_sprite/src/entity.rs

@@ -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};
 

crates/bevy_sprite/src/rect.rs

@@ -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)

crates/bevy_sprite/src/render/mod.rs

@@ -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::{
-    pipeline::{state_descriptors::*, PipelineDescriptor},
+        BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
-    render_graph::{
+        CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, PipelineDescriptor,
-        nodes::{AssetRenderResourcesNode, RenderResourcesNode},
+        RasterizationStateDescriptor, StencilStateFaceDescriptor,
-        RenderGraph,
     },
+    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(

crates/bevy_sprite/src/sprite.rs

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

crates/bevy_sprite/src/texture_atlas.rs

@@ -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;
 

crates/bevy_text/src/draw.rs

@@ -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};
 

crates/bevy_text/src/font.rs

@@ -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,

crates/bevy_text/src/font_atlas_set.rs

@@ -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;

crates/bevy_ui/src/node.rs

@@ -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)]

crates/bevy_ui/src/render/mod.rs

@@ -2,15 +2,11 @@ use crate::Node;
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::Resources;
 use bevy_render::{
-    base_render_graph,
+    camera::ActiveCameras,
-    pipeline::{state_descriptors::*, PipelineDescriptor},
+    pipeline::*,
-    render_graph::{
+    render_graph::{base, CameraNode, PassNode, RenderGraph, RenderResourcesNode},
-        nodes::{CameraNode, PassNode, RenderResourcesNode},
-        RenderGraph,
-    },
     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
+        let main_pass_node: &mut PassNode = self.get_node_mut(base::node::MAIN_PASS).unwrap();
-            .get_node_mut(base_render_graph::node::MAIN_PASS)
-            .unwrap();
         main_pass_node.add_camera(camera::UI_CAMERA);
         active_cameras.add(camera::UI_CAMERA);
         self

crates/bevy_ui/src/widget/label.rs

@@ -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};

crates/bevy_wgpu/src/lib.rs

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

crates/bevy_wgpu/src/renderer/wgpu_render_context.rs

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

crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs

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

crates/bevy_wgpu/src/wgpu_render_pass.rs

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

crates/bevy_wgpu/src/wgpu_resources.rs

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

crates/bevy_wgpu/src/wgpu_type_converter.rs

@@ -1,20 +1,18 @@
 use bevy_render::{
+    color::Color,
     pass::{LoadOp, Operations},
     pipeline::{
-        state_descriptors::{
+        BindType, BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
-            BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
+        CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, IndexFormat,
-            CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, IndexFormat,
+        InputStepMode, PrimitiveTopology, RasterizationStateDescriptor, StencilOperation,
-            PrimitiveTopology, RasterizationStateDescriptor, StencilOperation,
+        StencilStateFaceDescriptor, VertexAttributeDescriptor, VertexBufferDescriptor,
-            StencilStateFaceDescriptor,
+        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;
 

examples/3d/3d_scene.rs

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

examples/3d/parenting.rs

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

examples/3d/spawner.rs

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

examples/3d/texture.rs

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

examples/3d/z_sort_debug.rs

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

examples/app/dynamic_plugin_loading/example_plugin/src/lib.rs

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

examples/game/breakout.rs

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

examples/shader/shader_custom_material.rs

@@ -1,8 +1,11 @@
 use bevy::{
     prelude::*,
     render::{
-        base_render_graph,
+        mesh::shape,
-        pipeline::{DynamicBinding, PipelineSpecialization, RenderPipeline},
+        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

examples/shader/shader_defs.rs

@@ -1,9 +1,11 @@
 use bevy::{
     prelude::*,
     render::{
-        base_render_graph,
+        mesh::shape,
-        pipeline::{DynamicBinding, PipelineSpecialization, RenderPipeline},
+        pipeline::{DynamicBinding, PipelineDescriptor, PipelineSpecialization, RenderPipeline},
-        shader,
+        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

examples/window/clear_color.rs

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

examples/window/multiple_windows.rs

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

src/prelude.rs

@@ -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::{
+    render::prelude::*,
-        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,
-    },
     scene::{Scene, SceneSpawner},
     sprite::{
         entity::{SpriteComponents, SpriteSheetComponents},