feature gate bevy_render

Author: BenjaminBrienen

crates/bevy_image/src/image.rs

@@ -5,7 +5,7 @@ use super::dds::*;
 #[cfg(feature = "ktx2")]
 use super::ktx2::*;
 
-use bevy_asset::{Asset, RenderAssetUsages};
+use bevy_asset::{Asset, Handle, RenderAssetUsages};
 use bevy_color::{Color, ColorToComponents, Gray, LinearRgba, Srgba, Xyza};
 use bevy_math::{AspectRatio, UVec2, UVec3, Vec2};
 use bevy_reflect::std_traits::ReflectDefault;
@@ -278,6 +278,14 @@ impl ImageFormat {
     }
 }
 
+/// A handle to a 1 x 1 transparent white image.
+///
+/// Like [`Handle<Image>::default`], this is a handle to a fallback image asset.
+/// While that handle points to an opaque white 1 x 1 image, this handle points to a transparent 1 x 1 white image.
+// Number randomly selected by fair WolframAlpha query. Totally arbitrary.
+pub const TRANSPARENT_IMAGE_HANDLE: Handle<Image> =
+    Handle::weak_from_u128(154728948001857810431816125397303024160);
+
 #[derive(Asset, Reflect, Debug, Clone)]
 #[reflect(opaque)]
 #[reflect(Default, Debug)]

crates/bevy_render/src/texture/mod.rs

@@ -6,9 +6,16 @@ mod texture_cache;
 pub use crate::render_resource::DefaultImageSampler;
 #[cfg(feature = "basis-universal")]
 use bevy_image::CompressedImageSaver;
+#[cfg(feature = "exr")]
+pub use bevy_image::ExrTextureLoader;
 #[cfg(feature = "hdr")]
-use bevy_image::HdrTextureLoader;
-use bevy_image::{CompressedImageFormats, Image, ImageLoader, ImageSamplerDescriptor};
+pub use bevy_image::HdrTextureLoader;
+pub use bevy_image::{
+    BevyDefault, CompressedImageFormats, FileTextureError, Image, ImageAddressMode,
+    ImageFilterMode, ImageFormat, ImageFormatSetting, ImageLoader, ImageLoaderError,
+    ImageLoaderSettings, ImageSampler, ImageSamplerDescriptor, ImageType, IntoDynamicImageError,
+    TextureError, TextureFormatPixelInfo, TRANSPARENT_IMAGE_HANDLE,
+};
 pub use fallback_image::*;
 pub use gpu_image::*;
 pub use texture_attachment::*;
@@ -21,14 +28,6 @@ use bevy_app::{App, Plugin};
 use bevy_asset::{AssetApp, Assets, Handle};
 use bevy_ecs::prelude::*;
 
-/// A handle to a 1 x 1 transparent white image.
-///
-/// Like [`Handle<Image>::default`], this is a handle to a fallback image asset.
-/// While that handle points to an opaque white 1 x 1 image, this handle points to a transparent 1 x 1 white image.
-// Number randomly selected by fair WolframAlpha query. Totally arbitrary.
-pub const TRANSPARENT_IMAGE_HANDLE: Handle<Image> =
-    Handle::weak_from_u128(154728948001857810431816125397303024160);
-
 // TODO: replace Texture names with Image names?
 /// Adds the [`Image`] as an asset and makes sure that they are extracted and prepared for the GPU.
 pub struct ImagePlugin {
@@ -62,7 +61,7 @@ impl Plugin for ImagePlugin {
     fn build(&self, app: &mut App) {
         #[cfg(feature = "exr")]
         {
-            app.init_asset_loader::<bevy_image::ExrTextureLoader>();
+            app.init_asset_loader::<ExrTextureLoader>();
         }
 
         #[cfg(feature = "hdr")]

crates/bevy_ui/Cargo.toml

@@ -24,10 +24,10 @@ bevy_math = { path = "../bevy_math", version = "0.15.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.15.0-dev", features = [
   "bevy",
 ] }
-bevy_render = { path = "../bevy_render", version = "0.15.0-dev" }
+bevy_render = { path = "../bevy_render", version = "0.15.0-dev", optional = true }
 bevy_animation = { path = "../bevy_animation", version = "0.15.0-dev" }
 bevy_sprite = { path = "../bevy_sprite", version = "0.15.0-dev" }
-bevy_text = { path = "../bevy_text", version = "0.15.0-dev" }
+bevy_text = { path = "../bevy_text", version = "0.15.0-dev", optional = true }
 bevy_picking = { path = "../bevy_picking", version = "0.15.0-dev", optional = true }
 bevy_transform = { path = "../bevy_transform", version = "0.15.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.15.0-dev" }
@@ -47,7 +47,7 @@ smallvec = "1.11"
 accesskit = "0.17"
 
 [features]
-default = ["bevy_ui_picking_backend"]
+default = ["bevy_ui_picking_backend", "bevy_render"]
 serialize = ["serde", "smallvec/serde", "bevy_math/serialize"]
 bevy_ui_picking_backend = ["bevy_picking"]
 

crates/bevy_ui/src/accessibility.rs

@@ -1,22 +1,18 @@
-use crate::{
-    experimental::UiChildren,
-    prelude::{Button, Label},
-    widget::{ImageNode, TextUiReader},
-    ComputedNode,
-};
+use crate::TextUiReader;
+use crate::{experimental::UiChildren, prelude::Button, widget::ImageNode};
+use crate::{prelude::Label, ComputedNode};
 use bevy_a11y::AccessibilityNode;
-use bevy_app::{App, Plugin, PostUpdate};
+use bevy_app::{App, Plugin};
 use bevy_ecs::{
-    prelude::{DetectChanges, Entity},
+    prelude::Entity,
     query::{Changed, Without},
-    schedule::IntoSystemConfigs,
     system::{Commands, Query},
-    world::Ref,
 };
 use bevy_render::{camera::CameraUpdateSystem, prelude::Camera};
 use bevy_transform::prelude::GlobalTransform;
 
-use accesskit::{Node, Rect, Role};
+use accesskit::Rect;
+use accesskit::{Node, Role};
 
 fn calc_label(
     text_reader: &mut TextUiReader,
@@ -39,10 +35,11 @@ fn calc_bounds(
     camera: Query<(&Camera, &GlobalTransform)>,
     mut nodes: Query<(
         &mut AccessibilityNode,
-        Ref<ComputedNode>,
-        Ref<GlobalTransform>,
+        bevy_ecs::world::Ref<ComputedNode>,
+        bevy_ecs::world::Ref<GlobalTransform>,
     )>,
 ) {
+    use bevy_ecs::change_detection::DetectChanges as _;
     if let Ok((camera, camera_transform)) = camera.get_single() {
         for (mut accessible, node, transform) in &mut nodes {
             if node.is_changed() || transform.is_changed() {
@@ -154,8 +151,9 @@ pub(crate) struct AccessibilityPlugin;
 
 impl Plugin for AccessibilityPlugin {
     fn build(&self, app: &mut App) {
+        use bevy_ecs::schedule::IntoSystemConfigs as _;
         app.add_systems(
-            PostUpdate,
+            bevy_app::PostUpdate,
             (
                 calc_bounds
                     .after(bevy_transform::TransformSystem::TransformPropagate)

crates/bevy_ui/src/experimental/ghost_hierarchy.rs

@@ -3,6 +3,7 @@
 use bevy_ecs::{prelude::*, system::SystemParam};
 use bevy_hierarchy::{Children, HierarchyQueryExt, Parent};
 use bevy_reflect::prelude::*;
+#[cfg(feature = "bevy_render")]
 use bevy_render::view::Visibility;
 use bevy_transform::prelude::Transform;
 use core::marker::PhantomData;
@@ -20,7 +21,8 @@ use crate::Node;
 #[derive(Component, Debug, Copy, Clone, Reflect)]
 #[cfg_attr(feature = "ghost_nodes", derive(Default))]
 #[reflect(Component, Debug)]
-#[require(Visibility, Transform)]
+#[cfg_attr(feature = "bevy_render", require(Visibility))]
+#[require(Transform)]
 pub struct GhostNode {
     // This is a workaround to ensure that GhostNode is only constructable when the appropriate feature flag is enabled
     #[reflect(ignore)]

crates/bevy_ui/src/focus.rs

@@ -1,24 +1,22 @@
-use crate::{
-    CalculatedClip, ComputedNode, DefaultUiCamera, ResolvedBorderRadius, TargetCamera, UiScale,
-    UiStack,
-};
-use bevy_ecs::{
-    change_detection::DetectChangesMut,
-    entity::Entity,
-    prelude::{Component, With},
-    query::QueryData,
-    reflect::ReflectComponent,
-    system::{Local, Query, Res},
-};
-use bevy_input::{mouse::MouseButton, touch::Touches, ButtonInput};
+use crate::{CalculatedClip, ComputedNode};
+use bevy_ecs::{entity::Entity, prelude::Component, query::QueryData, reflect::ReflectComponent};
 use bevy_math::{Rect, Vec2};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
-use bevy_render::{camera::NormalizedRenderTarget, prelude::Camera, view::ViewVisibility};
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::HashMap;
-use bevy_window::{PrimaryWindow, Window};
 
-use smallvec::SmallVec;
+#[cfg(feature = "bevy_render")]
+use {
+    crate::{DefaultUiCamera, ResolvedBorderRadius, TargetCamera, UiScale, UiStack},
+    bevy_ecs::{
+        change_detection::DetectChangesMut as _,
+        prelude::With,
+        system::{Local, Query, Res},
+    },
+    bevy_input::{mouse::MouseButton, touch::Touches, ButtonInput},
+    bevy_render::{camera::NormalizedRenderTarget, prelude::Camera, view::ViewVisibility},
+    bevy_window::{PrimaryWindow, Window},
+    smallvec::SmallVec,
+};
 
 #[cfg(feature = "serialize")]
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
@@ -127,6 +125,7 @@ impl Default for FocusPolicy {
 
 /// Contains entities whose Interaction should be set to None
 #[derive(Default)]
+#[cfg(feature = "bevy_render")]
 pub struct State {
     entities_to_reset: SmallVec<[Entity; 1]>,
 }
@@ -142,14 +141,17 @@ pub struct NodeQuery {
     relative_cursor_position: Option<&'static mut RelativeCursorPosition>,
     focus_policy: Option<&'static FocusPolicy>,
     calculated_clip: Option<&'static CalculatedClip>,
+    #[cfg(feature = "bevy_render")]
     view_visibility: Option<&'static ViewVisibility>,
+    #[cfg(feature = "bevy_render")]
     target_camera: Option<&'static TargetCamera>,
 }
 
 /// The system that sets Interaction for all UI elements based on the mouse cursor activity
 ///
 /// Entities with a hidden [`ViewVisibility`] are always treated as released.
 #[allow(clippy::too_many_arguments)]
+#[cfg(feature = "bevy_render")]
 pub fn ui_focus_system(
     mut state: Local<State>,
     camera_query: Query<(Entity, &Camera)>,
@@ -190,7 +192,7 @@ pub fn ui_focus_system(
     let mouse_clicked =
         mouse_button_input.just_pressed(MouseButton::Left) || touches_input.any_just_pressed();
 
-    let camera_cursor_positions: HashMap<Entity, Vec2> = camera_query
+    let camera_cursor_positions: bevy_utils::HashMap<Entity, Vec2> = camera_query
         .iter()
         .filter_map(|(entity, camera)| {
             // Interactions are only supported for cameras rendering to a window.
@@ -351,6 +353,7 @@ pub fn ui_focus_system(
 // the given size and border radius.
 //
 // Matches the sdf function in `ui.wgsl` that is used by the UI renderer to draw rounded rectangles.
+#[cfg(feature = "bevy_render")]
 pub(crate) fn pick_rounded_rect(
     point: Vec2,
     size: Vec2,

crates/bevy_ui/src/layout/mod.rs

@@ -1,8 +1,9 @@
 use crate::{
     experimental::{UiChildren, UiRootNodes},
-    BorderRadius, ComputedNode, ContentSize, DefaultUiCamera, Display, Node, Outline, OverflowAxis,
-    ScrollPosition, TargetCamera, UiScale,
+    BorderRadius, ComputedNode, ContentSize, Display, Node, Outline, OverflowAxis, ScrollPosition,
+    UiScale,
 };
+use crate::{DefaultUiCamera, TargetCamera};
 use bevy_ecs::{
     change_detection::{DetectChanges, DetectChangesMut},
     entity::{Entity, EntityHashMap, EntityHashSet},
@@ -22,9 +23,8 @@ use bevy_window::{PrimaryWindow, Window, WindowScaleFactorChanged};
 use derive_more::derive::{Display, Error, From};
 use ui_surface::UiSurface;
 
-use bevy_text::ComputedTextBlock;
-
-use bevy_text::CosmicFontSystem;
+#[cfg(feature = "bevy_text")]
+use bevy_text::{ComputedTextBlock, CosmicFontSystem};
 
 mod convert;
 pub mod debug;
@@ -132,8 +132,8 @@ pub fn ui_layout_system(
         Option<&Outline>,
         Option<&ScrollPosition>,
     )>,
-    mut buffer_query: Query<&mut ComputedTextBlock>,
-    mut font_system: ResMut<CosmicFontSystem>,
+    #[cfg(feature = "bevy_text")] mut buffer_query: Query<&mut ComputedTextBlock>,
+    #[cfg(feature = "bevy_text")] mut font_system: ResMut<CosmicFontSystem>,
 ) {
     let UiLayoutSystemBuffers {
         interned_root_nodes,
@@ -276,6 +276,7 @@ with UI components as a child of an entity without UI components, your UI layout
             }
         });
 
+    #[cfg(feature = "bevy_text")]
     let text_buffers = &mut buffer_query;
     // clean up removed nodes after syncing children to avoid potential panic (invalid SlotMap key used)
     ui_surface.remove_entities(
@@ -292,10 +293,11 @@ with UI components as a child of an entity without UI components, your UI layout
         }
     });
 
-    for (camera_id, mut camera) in camera_layout_info.drain() {
+    for (_camera_id, mut camera) in camera_layout_info.drain() {
         let inverse_target_scale_factor = camera.scale_factor.recip();
 
-        ui_surface.compute_camera_layout(camera_id, camera.size, text_buffers, &mut font_system);
+        #[cfg(feature = "bevy_text")]
+        ui_surface.compute_camera_layout(_camera_id, camera.size, text_buffers, &mut font_system);
 
         for root in &camera.root_nodes {
             update_uinode_geometry_recursive(
@@ -504,13 +506,12 @@ mod tests {
         world.init_resource::<Events<AssetEvent<Image>>>();
         world.init_resource::<Assets<Image>>();
         world.init_resource::<ManualTextureViews>();
-
-        world.init_resource::<bevy_text::TextPipeline>();
-
-        world.init_resource::<bevy_text::CosmicFontSystem>();
-
-        world.init_resource::<bevy_text::SwashCache>();
-
+        #[cfg(feature = "bevy_text")]
+        {
+            world.init_resource::<bevy_text::TextPipeline>();
+            world.init_resource::<bevy_text::CosmicFontSystem>();
+            world.init_resource::<bevy_text::SwashCache>();
+        }
         // spawn a dummy primary window and camera
         world.spawn((
             Window {
@@ -1149,13 +1150,12 @@ mod tests {
         world.init_resource::<Events<AssetEvent<Image>>>();
         world.init_resource::<Assets<Image>>();
         world.init_resource::<ManualTextureViews>();
-
-        world.init_resource::<bevy_text::TextPipeline>();
-
-        world.init_resource::<bevy_text::CosmicFontSystem>();
-
-        world.init_resource::<bevy_text::SwashCache>();
-
+        #[cfg(feature = "bevy_text")]
+        {
+            world.init_resource::<bevy_text::TextPipeline>();
+            world.init_resource::<bevy_text::CosmicFontSystem>();
+            world.init_resource::<bevy_text::SwashCache>();
+        }
         // spawn a dummy primary window and camera
         world.spawn((
             Window {
@@ -1215,16 +1215,18 @@ mod tests {
         fn test_system(
             params: In<TestSystemParam>,
             mut ui_surface: ResMut<UiSurface>,
-            mut computed_text_block_query: Query<&mut bevy_text::ComputedTextBlock>,
-            mut font_system: ResMut<bevy_text::CosmicFontSystem>,
+            #[cfg(feature = "bevy_text")] mut computed_text_block_query: Query<
+                &mut bevy_text::ComputedTextBlock,
+            >,
+            #[cfg(feature = "bevy_text")] mut font_system: ResMut<bevy_text::CosmicFontSystem>,
         ) {
             ui_surface.upsert_node(
                 &LayoutContext::TEST_CONTEXT,
                 params.root_node_entity,
                 &Node::default(),
                 None,
             );
-
+            #[cfg(feature = "bevy_text")]
             ui_surface.compute_camera_layout(
                 params.camera_entity,
                 UVec2::new(800, 600),