added GpuPlugin

extracted the gpu code into a separate crate

renamed GPU* to Gpu*

renamed occurrences of the variable name `device` that refer to a `GPUDevice` to `gpu_device`
renamed occurrences of the variable name `queue` that refer to a `GPUQueue` to `gpu_queue`

renamed type names Render{Device, Queue, Adapter, AdapterInfo, Instance, Context} to GPU{Device, Queue, Adapter, AdapterInfo, Instance, Context}
renamed variable names render_{device, queue, adapter, adapter_info, instance, context} to gpu_{device, queue, adapter, adapter_info, instance, context}

Cargo.toml

@@ -35,6 +35,7 @@ default = [
   "bevy_core_pipeline",
   "bevy_pbr",
   "bevy_gltf",
+  "bevy_gpu",
   "bevy_render",
   "bevy_sprite",
   "bevy_text",
@@ -57,6 +58,7 @@ bevy_core_pipeline = ["bevy_internal/bevy_core_pipeline"]
 bevy_dynamic_plugin = ["bevy_internal/bevy_dynamic_plugin"]
 bevy_gilrs = ["bevy_internal/bevy_gilrs"]
 bevy_gltf = ["bevy_internal/bevy_gltf"]
+bevy_gpu = ["bevy_internal/bevy_gpu"]
 bevy_pbr = ["bevy_internal/bevy_pbr"]
 bevy_render = ["bevy_internal/bevy_render"]
 bevy_scene = ["bevy_internal/bevy_scene"]

crates/bevy_core_pipeline/Cargo.toml

@@ -22,6 +22,7 @@ bevy_app = { path = "../bevy_app", version = "0.9.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.9.0" }
 bevy_derive = { path = "../bevy_derive", version = "0.9.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.9.0" }
+bevy_gpu = { path = "../bevy_gpu", version = "0.9.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.9.0" }
 bevy_render = { path = "../bevy_render", version = "0.9.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.9.0" }

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -7,6 +7,7 @@ use bevy_ecs::{
     system::{Commands, Query, Res, ResMut, Resource},
     world::{FromWorld, World},
 };
+use bevy_gpu::{gpu_resource::*, GpuContext, GpuDevice};
 use bevy_math::UVec2;
 use bevy_reflect::{Reflect, TypeUuid};
 use bevy_render::{
@@ -18,8 +19,6 @@ use bevy_render::{
     prelude::Camera,
     render_graph::{Node, NodeRunError, RenderGraph, RenderGraphContext, SlotInfo, SlotType},
     render_phase::TrackedRenderPass,
-    render_resource::*,
-    renderer::{GpuContext, GpuDevice},
     texture::{CachedTexture, TextureCache},
     view::ViewTarget,
     RenderApp, RenderStage,

crates/bevy_core_pipeline/src/core_2d/main_pass_2d_node.rs

@@ -3,12 +3,14 @@ use crate::{
     core_2d::{camera_2d::Camera2d, Transparent2d},
 };
 use bevy_ecs::prelude::*;
+use bevy_gpu::{
+    gpu_resource::{LoadOp, Operations, RenderPassDescriptor},
+    GpuContext,
+};
 use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
-    render_phase::RenderPhase,
-    render_resource::{LoadOp, Operations, RenderPassDescriptor},
-    renderer::GpuContext,
+    render_phase::{DrawFunctions, RenderPhase, TrackedRenderPass},
     view::{ExtractedView, ViewTarget},
 };
 #[cfg(feature = "trace")]

crates/bevy_core_pipeline/src/core_2d/mod.rs

@@ -21,6 +21,7 @@ pub use main_pass_2d_node::*;
 
 use bevy_app::{App, Plugin};
 use bevy_ecs::prelude::*;
+use bevy_gpu::gpu_resource::CachedRenderPipelineId;
 use bevy_render::{
     camera::Camera,
     extract_component::ExtractComponentPlugin,
@@ -29,7 +30,6 @@ use bevy_render::{
         batch_phase_system, sort_phase_system, BatchedPhaseItem, CachedRenderPipelinePhaseItem,
         DrawFunctionId, DrawFunctions, EntityPhaseItem, PhaseItem, RenderPhase,
     },
-    render_resource::CachedRenderPipelineId,
     Extract, RenderApp, RenderStage,
 };
 use bevy_utils::FloatOrd;

crates/bevy_core_pipeline/src/core_3d/camera_3d.rs

@@ -1,11 +1,11 @@
 use crate::{clear_color::ClearColorConfig, tonemapping::Tonemapping};
 use bevy_ecs::{prelude::*, query::QueryItem};
+use bevy_gpu::gpu_resource::LoadOp;
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
 use bevy_render::{
     camera::{Camera, CameraRenderGraph, Projection},
     extract_component::ExtractComponent,
     primitives::Frustum,
-    render_resource::LoadOp,
     view::VisibleEntities,
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};

crates/bevy_core_pipeline/src/core_3d/main_pass_3d_node.rs

@@ -3,12 +3,14 @@ use crate::{
     core_3d::{AlphaMask3d, Camera3d, Opaque3d, Transparent3d},
 };
 use bevy_ecs::prelude::*;
+use bevy_gpu::{
+    gpu_resource::{LoadOp, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor},
+    GpuContext,
+};
 use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
-    render_phase::RenderPhase,
-    render_resource::{LoadOp, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor},
-    renderer::GpuContext,
+    render_phase::{DrawFunctions, RenderPhase, TrackedRenderPass},
     view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
 #[cfg(feature = "trace")]
@@ -95,13 +97,20 @@ impl Node for MainPass3dNode {
                 }),
             };
 
-            opaque_phase.render(
-                world,
-                gpu_context,
-                view_entity,
-                camera.viewport.as_ref(),
-                pass_descriptor,
-            );
+            let draw_functions = world.resource::<DrawFunctions<Opaque3d>>();
+
+            let render_pass = render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
+            let mut draw_functions = draw_functions.write();
+            let mut tracked_pass = TrackedRenderPass::new(render_pass);
+            if let Some(viewport) = camera.viewport.as_ref() {
+                tracked_pass.set_camera_viewport(viewport);
+            }
+            for item in &opaque_phase.items {
+                let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+                draw_function.draw(world, &mut tracked_pass, view_entity, item);
+            }
         }
 
         if !alpha_mask_phase.items.is_empty() {
@@ -127,13 +136,20 @@ impl Node for MainPass3dNode {
                 }),
             };
 
-            alpha_mask_phase.render(
-                world,
-                gpu_context,
-                view_entity,
-                camera.viewport.as_ref(),
-                pass_descriptor,
-            );
+            let draw_functions = world.resource::<DrawFunctions<AlphaMask3d>>();
+
+            let render_pass = render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
+            let mut draw_functions = draw_functions.write();
+            let mut tracked_pass = TrackedRenderPass::new(render_pass);
+            if let Some(viewport) = camera.viewport.as_ref() {
+                tracked_pass.set_camera_viewport(viewport);
+            }
+            for item in &alpha_mask_phase.items {
+                let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+                draw_function.draw(world, &mut tracked_pass, view_entity, item);
+            }
         }
 
         if !transparent_phase.items.is_empty() {

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -23,6 +23,13 @@ pub use main_pass_3d_node::*;
 
 use bevy_app::{App, Plugin};
 use bevy_ecs::prelude::*;
+use bevy_gpu::{
+    gpu_resource::{
+        CachedRenderPipelineId, Extent3d, TextureDescriptor, TextureDimension, TextureFormat,
+        TextureUsages,
+    },
+    GpuDevice,
+};
 use bevy_render::{
     camera::{Camera, ExtractedCamera},
     extract_component::ExtractComponentPlugin,
@@ -32,11 +39,6 @@ use bevy_render::{
         sort_phase_system, CachedRenderPipelinePhaseItem, DrawFunctionId, DrawFunctions,
         EntityPhaseItem, PhaseItem, RenderPhase,
     },
-    render_resource::{
-        CachedRenderPipelineId, Extent3d, TextureDescriptor, TextureDimension, TextureFormat,
-        TextureUsages,
-    },
-    renderer::GpuDevice,
     texture::TextureCache,
     view::ViewDepthTexture,
     Extract, RenderApp, RenderStage,

crates/bevy_core_pipeline/src/fullscreen_vertex_shader/mod.rs

@@ -1,6 +1,6 @@
 use bevy_asset::HandleUntyped;
+use bevy_gpu::{gpu_resource::VertexState, prelude::Shader};
 use bevy_reflect::TypeUuid;
-use bevy_render::{prelude::Shader, render_resource::VertexState};
 
 pub const FULLSCREEN_SHADER_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 7837534426033940724);

crates/bevy_core_pipeline/src/fxaa/mod.rs

@@ -3,13 +3,12 @@ use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, HandleUntyped};
 use bevy_derive::Deref;
 use bevy_ecs::{prelude::*, query::QueryItem};
+use bevy_gpu::{gpu_resource::*, GpuDevice};
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     extract_component::{ExtractComponent, ExtractComponentPlugin},
     prelude::Camera,
     render_graph::RenderGraph,
-    render_resource::*,
-    renderer::GpuDevice,
     texture::BevyDefault,
     view::{ExtractedView, ViewTarget},
     RenderApp, RenderStage,

crates/bevy_core_pipeline/src/fxaa/node.rs

@@ -3,14 +3,16 @@ use std::sync::Mutex;
 use crate::fxaa::{CameraFxaaPipeline, Fxaa, FxaaPipeline};
 use bevy_ecs::prelude::*;
 use bevy_ecs::query::QueryState;
-use bevy_render::{
-    render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
-    render_resource::{
+use bevy_gpu::{
+    gpu_resource::{
         BindGroup, BindGroupDescriptor, BindGroupEntry, BindingResource, FilterMode, Operations,
         PipelineCache, RenderPassColorAttachment, RenderPassDescriptor, SamplerDescriptor,
         TextureViewId,
     },
-    renderer::GpuContext,
+    GpuContext,
+};
+use bevy_render::{
+    render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     view::{ExtractedView, ViewTarget},
 };
 use bevy_utils::default;

crates/bevy_core_pipeline/src/lib.rs

@@ -28,7 +28,8 @@ use crate::{
 };
 use bevy_app::{App, Plugin};
 use bevy_asset::load_internal_asset;
-use bevy_render::{extract_resource::ExtractResourcePlugin, prelude::Shader};
+use bevy_gpu::prelude::Shader;
+use bevy_render::extract_resource::ExtractResourcePlugin;
 
 #[derive(Default)]
 pub struct CorePipelinePlugin;

crates/bevy_core_pipeline/src/tonemapping/mod.rs

@@ -1,14 +1,15 @@
 use crate::fullscreen_vertex_shader::fullscreen_shader_vertex_state;
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, HandleUntyped};
-use bevy_ecs::prelude::*;
-use bevy_ecs::query::QueryItem;
+use bevy_ecs::{prelude::*, query::QueryItem};
+use bevy_gpu::{gpu_resource::*, GpuDevice};
 use bevy_reflect::{Reflect, TypeUuid};
-use bevy_render::camera::Camera;
-use bevy_render::extract_component::{ExtractComponent, ExtractComponentPlugin};
-use bevy_render::renderer::GpuDevice;
-use bevy_render::view::ViewTarget;
-use bevy_render::{render_resource::*, RenderApp, RenderStage};
+use bevy_render::{
+    camera::Camera,
+    extract_component::{ExtractComponent, ExtractComponentPlugin},
+    view::ViewTarget,
+    RenderApp, RenderStage,
+};
 
 mod node;
 

crates/bevy_core_pipeline/src/tonemapping/node.rs

@@ -3,14 +3,9 @@ use std::sync::Mutex;
 use crate::tonemapping::{TonemappingPipeline, ViewTonemappingPipeline};
 use bevy_ecs::prelude::*;
 use bevy_ecs::query::QueryState;
+use bevy_gpu::{gpu_resource::*, GpuContext};
 use bevy_render::{
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
-    render_resource::{
-        BindGroup, BindGroupDescriptor, BindGroupEntry, BindingResource, LoadOp, Operations,
-        PipelineCache, RenderPassColorAttachment, RenderPassDescriptor, SamplerDescriptor,
-        TextureViewId,
-    },
-    renderer::GpuContext,
     view::{ExtractedView, ViewTarget},
 };
 
@@ -111,7 +106,7 @@ impl Node for TonemappingNode {
         };
 
         let mut render_pass = gpu_context
-            .gpu_command_encoder
+            .command_encoder
             .begin_render_pass(&pass_descriptor);
 
         render_pass.set_pipeline(pipeline);

crates/bevy_core_pipeline/src/upscaling/mod.rs

@@ -2,10 +2,9 @@ use crate::fullscreen_vertex_shader::fullscreen_shader_vertex_state;
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, HandleUntyped};
 use bevy_ecs::prelude::*;
+use bevy_gpu::{gpu_resource::*, GpuDevice};
 use bevy_reflect::TypeUuid;
-use bevy_render::renderer::GpuDevice;
-use bevy_render::view::ViewTarget;
-use bevy_render::{render_resource::*, RenderApp, RenderStage};
+use bevy_render::{view::ViewTarget, RenderApp, RenderStage};
 
 mod node;
 

crates/bevy_core_pipeline/src/upscaling/node.rs

@@ -2,14 +2,9 @@ use std::sync::Mutex;
 
 use bevy_ecs::prelude::*;
 use bevy_ecs::query::QueryState;
+use bevy_gpu::{gpu_resource::*, GpuContext};
 use bevy_render::{
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
-    render_resource::{
-        BindGroup, BindGroupDescriptor, BindGroupEntry, BindingResource, LoadOp, Operations,
-        PipelineCache, RenderPassColorAttachment, RenderPassDescriptor, SamplerDescriptor,
-        TextureViewId,
-    },
-    renderer::GpuContext,
     view::{ExtractedView, ViewTarget},
 };
 

crates/bevy_encase_derive/src/lib.rs

@@ -2,7 +2,7 @@ use bevy_macro_utils::BevyManifest;
 use encase_derive_impl::{implement, syn};
 
 const BEVY: &str = "bevy";
-const BEVY_RENDER: &str = "bevy_render";
+const BEVY_GPU: &str = "bevy_gpu";
 const ENCASE: &str = "encase";
 
 fn bevy_encase_path() -> syn::Path {
@@ -17,10 +17,10 @@ fn bevy_encase_path() -> syn::Path {
                 segments,
             }
         })
-        .or_else(|| bevy_manifest.maybe_get_path(BEVY_RENDER))
-        .map(|bevy_render_path| {
-            let mut segments = bevy_render_path.segments;
-            segments.push(BevyManifest::parse_str("render_resource"));
+        .or_else(|| bevy_manifest.maybe_get_path(BEVY_GPU))
+        .map(|bevy_gpu_path| {
+            let mut segments = bevy_gpu_path.segments;
+            segments.push(BevyManifest::parse_str("gpu_resource"));
             syn::Path {
                 leading_colon: None,
                 segments,

crates/bevy_gltf/Cargo.toml

@@ -16,6 +16,7 @@ bevy_asset = { path = "../bevy_asset", version = "0.9.0" }
 bevy_core = { path = "../bevy_core", version = "0.9.0" }
 bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.9.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.9.0" }
+bevy_gpu = { path = "../bevy_gpu", version = "0.9.0" }
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.9.0" }
 bevy_log = { path = "../bevy_log", version = "0.9.0" }
 bevy_math = { path = "../bevy_math", version = "0.9.0" }

crates/bevy_gltf/src/loader.rs

@@ -5,6 +5,7 @@ use bevy_asset::{
 use bevy_core::Name;
 use bevy_core_pipeline::prelude::Camera3d;
 use bevy_ecs::{entity::Entity, prelude::FromWorld, world::World};
+use bevy_gpu::{gpu_resource::*, GpuDevice};
 use bevy_hierarchy::{BuildWorldChildren, WorldChildBuilder};
 use bevy_log::warn;
 use bevy_math::{Mat4, Vec3};
@@ -24,8 +25,6 @@ use bevy_render::{
     },
     prelude::SpatialBundle,
     primitives::{Aabb, Frustum},
-    render_resource::{AddressMode, Face, FilterMode, PrimitiveTopology, SamplerDescriptor},
-    renderer::GpuDevice,
     texture::{CompressedImageFormats, Image, ImageSampler, ImageType, TextureError},
     view::VisibleEntities,
 };