From c22bf9b511e468067df8eae45916191c66439ea7 Mon Sep 17 00:00:00 2001 From: Schmarni Date: Sun, 29 Jun 2025 22:37:52 +0200 Subject: [PATCH] refactor: switch to bevys StandardMaterial for now Signed-off-by: Schmarni --- Cargo.lock | 1 - Cargo.toml | 3 +- src/main.rs | 12 +++--- src/nodes/drawable/lines.rs | 14 +++--- src/nodes/drawable/model.rs | 69 +++++++++++++++--------------- src/nodes/drawable/text.rs | 17 +++----- src/objects/input/sk_controller.rs | 1 - src/objects/input/sk_hand.rs | 27 ++++++------ 8 files changed, 69 insertions(+), 75 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f9ca5bf..19b3511 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1432,7 +1432,6 @@ dependencies = [ [[package]] name = "bevy_sk" version = "0.1.0" -source = "git+https://github.com/Schmarni-Dev/bevy_sk?branch=fix_mat_stuff#744e9bb442a690b1abc15f50ba2655228bd84eea" dependencies = [ "bevy", "bevy_mod_xr", diff --git a/Cargo.toml b/Cargo.toml index d285f93..fe1779a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -83,7 +83,8 @@ bevy = { version = "0.16", features = ["wayland", "bevy_remote", "mp3", "wav"] } bevy_mod_xr = "0.3" bevy_mod_openxr = "0.3" # bevy_sk.git = "https://github.com/MalekiRe/bevy_sk" -bevy_sk = { git = "https://github.com/Schmarni-Dev/bevy_sk", branch = "fix_mat_stuff" } +# bevy_sk = { git = "https://github.com/Schmarni-Dev/bevy_sk", branch = "fix_mat_stuff" } +bevy_sk.path = "../bevy_sk" bevy-mesh-text-3d.git = "https://github.com/terhechte/bevy-mesh-text-3d" openxr = "0.19" diff --git a/src/main.rs b/src/main.rs index b54daa9..2e8fa7c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -39,7 +39,6 @@ use bevy_mod_openxr::render::{OxrRenderPlugin, OxrWaitFrameSystem}; use bevy_mod_openxr::resources::{OxrFrameState, OxrFrameWaiter, OxrSessionConfig}; use bevy_mod_openxr::types::AppInfo; use bevy_mod_xr::camera::XrProjection; -use bevy_mod_xr::hand_debug_gizmos::HandGizmosPlugin; use bevy_mod_xr::session::{XrFirst, XrHandleEvents}; use clap::Parser; use core::client::{Client, tick_internal_client}; @@ -108,6 +107,8 @@ struct CliArgs { nvidia: bool, } +pub type BevyMaterial = StandardMaterial; + static STARDUST_INSTANCE: OnceLock = OnceLock::new(); // #[tokio::main(flavor = "current_thread")] @@ -350,13 +351,14 @@ fn bevy_loop( app.add_plugins(( bevy_sk::hand::HandPlugin, - bevy_sk::vr_materials::SkMaterialPlugin { - replace_standard_material: true, - }, - bevy_sk::skytext::SphericalHarmonicsPlugin, + // bevy_sk::vr_materials::SkMaterialPlugin { + // replace_standard_material: false, + // }, + // bevy_sk::skytext::SphericalHarmonicsPlugin, )); // app.add_plugins(HandGizmosPlugin); app.init_asset::().init_asset_loader::(); + app.world_mut().resource_mut::().brightness = 2000.0; if let Some(priority) = args.overlay_priority { app.insert_resource(OxrOverlaySettings { session_layer_placement: priority, diff --git a/src/nodes/drawable/lines.rs b/src/nodes/drawable/lines.rs index 61c16f8..f8cc4a5 100644 --- a/src/nodes/drawable/lines.rs +++ b/src/nodes/drawable/lines.rs @@ -5,9 +5,8 @@ use crate::{ registry::Registry, }, nodes::{ - Node, - spatial::{Spatial, SpatialNode}, - }, + spatial::{Spatial, SpatialNode}, Node + }, BevyMaterial, }; use bevy::{ asset::RenderAssetUsages, @@ -17,7 +16,6 @@ use bevy::{ primitives::Aabb, }, }; -use bevy_sk::vr_materials::PbrMaterial; use glam::Vec3; use parking_lot::Mutex; use std::sync::{ @@ -54,7 +52,7 @@ fn update_visibillity(mut cmds: Commands) { fn build_line_mesh( mut meshes: ResMut>, mut cmds: Commands, - mut materials: ResMut>, + mut materials: ResMut>, ) { for lines in LINES_REGISTRY .get_valid_contents() @@ -171,9 +169,9 @@ fn build_line_mesh( let e = cmds.spawn(( Name::new("LinesNode"), SpatialNode(Arc::downgrade(&lines.spatial)), - MeshMaterial3d(materials.add(PbrMaterial { - color: Color::WHITE, - roughness: 1.0, + MeshMaterial3d(materials.add(BevyMaterial { + base_color: Color::WHITE, + perceptual_roughness: 1.0, alpha_mode: AlphaMode::Opaque, ..default() })), diff --git a/src/nodes/drawable/model.rs b/src/nodes/drawable/model.rs index 833bc81..9f0a51d 100644 --- a/src/nodes/drawable/model.rs +++ b/src/nodes/drawable/model.rs @@ -1,5 +1,4 @@ use super::{MODEL_PART_ASPECT_ALIAS_INFO, MaterialParameter, ModelAspect, ModelPartAspect}; -use crate::bail; use crate::core::bevy_channel::{BevyChannel, BevyChannelReader}; use crate::core::client::Client; use crate::core::color::ColorConvert as _; @@ -10,9 +9,9 @@ use crate::core::resource::get_resource_file; use crate::nodes::Node; use crate::nodes::alias::{Alias, AliasList}; use crate::nodes::spatial::{Spatial, SpatialNode}; +use crate::{BevyMaterial, bail}; use bevy::prelude::*; use bevy::render::primitives::Aabb; -use bevy_sk::vr_materials::PbrMaterial; use color_eyre::eyre::eyre; use parking_lot::Mutex; use rustc_hash::{FxHashMap, FxHasher}; @@ -79,10 +78,10 @@ fn load_models( } fn apply_materials( - mut query: Query<&mut MeshMaterial3d>, + mut query: Query<&mut MeshMaterial3d>, mut material_registry: ResMut, asset_server: Res, - mut materials: ResMut>, + mut materials: ResMut>, ) -> bevy::prelude::Result { for model_part in MODEL_REGISTRY .get_valid_contents() @@ -248,16 +247,16 @@ fn gen_path( #[derive(PartialEq, Deref, DerefMut, Clone, Copy, Eq, PartialOrd, Ord, Hash)] struct HashedPbrMaterial(u64); impl HashedPbrMaterial { - fn new(material: &PbrMaterial) -> Self { + fn new(material: &BevyMaterial) -> Self { let mut hasher = FxHasher::default(); Self::hash_pbr_mat(material, &mut hasher); Self(hasher.finish()) } - fn hash_pbr_mat(mat: &PbrMaterial, state: &mut H) { - hash_color(mat.color, state); - hash_color(mat.emission_factor, state); + fn hash_pbr_mat(mat: &BevyMaterial, state: &mut H) { + hash_color(mat.base_color, state); + hash_color(mat.emissive.into(), state); state.write_u32(mat.metallic.to_bits()); - state.write_u32(mat.roughness.to_bits()); + state.write_u32(mat.perceptual_roughness.to_bits()); match mat.alpha_mode { AlphaMode::Opaque => state.write_u8(0), AlphaMode::Mask(v) => { @@ -271,12 +270,12 @@ impl HashedPbrMaterial { AlphaMode::Multiply => state.write_u8(6), } state.write_u8(mat.double_sided as u8); - mat.diffuse_texture.hash(state); - mat.emission_texture.hash(state); - mat.metal_texture.hash(state); + mat.base_color_texture.hash(state); + mat.emissive_texture.hash(state); + mat.metallic_roughness_texture.hash(state); mat.occlusion_texture.hash(state); // should always be the same, TODO: make the spherical harmonics buffer a per mesh instance thing - mat.spherical_harmonics.hash(state); + // mat.spherical_harmonics.hash(state); } } fn hash_color(color: Color, state: &mut H) { @@ -347,7 +346,7 @@ impl MaterialParameter { fn apply_to_material( &self, client: &Client, - mat: &mut PbrMaterial, + mat: &mut BevyMaterial, parameter_name: &str, asset_server: &AssetServer, ) { @@ -367,7 +366,7 @@ impl MaterialParameter { MaterialParameter::Float(val) => { match parameter_name { "metallic" => mat.metallic = *val, - "roughness" => mat.roughness = *val, + "roughness" => mat.perceptual_roughness = *val, // we probably don't want to expose tex_scale // "tex_scale" => mat.tex_scale = *val, v => { @@ -382,8 +381,8 @@ impl MaterialParameter { // nothing uses a Vec3 } MaterialParameter::Color(color) => match parameter_name { - "color" => mat.color = color.to_bevy(), - "emission_factor" => mat.emission_factor = color.to_bevy(), + "color" => mat.base_color = color.to_bevy(), + "emission_factor" => mat.emissive = color.to_bevy().to_linear(), v => { error!("unknown param_name ({v}) for color") } @@ -396,16 +395,15 @@ impl MaterialParameter { }; let handle = asset_server.load(texture_path); match parameter_name { - "diffuse" => mat.diffuse_texture = Some(handle), - "emission" => mat.emission_texture = Some(handle), - "metal" => mat.metal_texture = Some(handle), + "diffuse" => mat.base_color_texture = Some(handle), + "emission" => mat.emissive_texture = Some(handle), + "metal" => mat.metallic_roughness_texture = Some(handle), "occlusion" => mat.occlusion_texture = Some(handle), v => { error!("unknown param_name ({v}) for texture"); - return; } } - mat.alpha_mode = AlphaMode::AlphaToCoverage; + // mat.alpha_mode = AlphaMode::Blend; } } } @@ -426,23 +424,23 @@ pub struct Material { } impl Material { - fn to_pbr_mat(&self, asset_server: &AssetServer) -> PbrMaterial { - PbrMaterial { - color: self.color, - emission_factor: self.emission_factor, + fn to_pbr_mat(&self, asset_server: &AssetServer) -> BevyMaterial { + BevyMaterial { + base_color: self.color, + emissive: self.emission_factor.to_linear(), metallic: self.metallic, - roughness: self.roughness, + perceptual_roughness: self.roughness, alpha_mode: self.alpha_mode, double_sided: self.double_sided, - diffuse_texture: self + base_color_texture: self .diffuse_texture .as_ref() .map(|p| asset_server.load(p.as_path())), - emission_texture: self + emissive_texture: self .emission_texture .as_ref() .map(|p| asset_server.load(p.as_path())), - metal_texture: self + metallic_roughness_texture: self .metal_texture .as_ref() .map(|p| asset_server.load(p.as_path())), @@ -450,7 +448,8 @@ impl Material { .occlusion_texture .as_ref() .map(|p| asset_server.load(p.as_path())), - spherical_harmonics: bevy_sk::skytext::SPHERICAL_HARMONICS_HANDLE, + ..Default::default() + // spherical_harmonics: bevy_sk::skytext::SPHERICAL_HARMONICS_HANDLE, } } } @@ -510,14 +509,14 @@ impl ModelPartAspect for ModelPart { } } #[derive(Default, Resource)] -pub struct MaterialRegistry(FxHashMap>); +pub struct MaterialRegistry(FxHashMap>); impl MaterialRegistry { /// returns strong handle for PbrMaterial elminitating duplications pub fn get_handle( &mut self, - material: PbrMaterial, - materials: &mut ResMut>, - ) -> Handle { + material: BevyMaterial, + materials: &mut ResMut>, + ) -> Handle { let hash = HashedPbrMaterial::new(&material); match self .0 diff --git a/src/nodes/drawable/text.rs b/src/nodes/drawable/text.rs index ba87c8d..17d2587 100644 --- a/src/nodes/drawable/text.rs +++ b/src/nodes/drawable/text.rs @@ -9,17 +9,14 @@ use crate::{ resource::get_resource_file, }, nodes::{ - Node, - drawable::XAlign, - spatial::{Spatial, SpatialNode}, - }, + drawable::XAlign, spatial::{Spatial, SpatialNode}, Node + }, BevyMaterial, }; use bevy::{platform::collections::HashMap, prelude::*}; use bevy_mesh_text_3d::{ Align, Attrs, MeshTextPlugin, Settings as FontSettings, generate_meshes, text_glyphs::TextGlyphs, }; -use bevy_sk::vr_materials::PbrMaterial; use color_eyre::eyre::eyre; use core::f32; use cosmic_text::Metrics; @@ -70,7 +67,7 @@ fn spawn_text( mut cmds: Commands, mut font_settings: ResMut, mut material_registry: ResMut, - mut materials: ResMut>, + mut materials: ResMut>, mut meshes: ResMut>, mut font_registry: Local, ) { @@ -109,11 +106,11 @@ fn spawn_text( bevy_mesh_text_3d::InputText::Simple { text: text_string, material: material_registry.get_handle( - PbrMaterial { - color: style.color.to_bevy(), - emission_factor: Color::WHITE, + BevyMaterial { + base_color: style.color.to_bevy(), + emissive: Color::WHITE.to_linear(), metallic: 0.0, - roughness: 1.0, + perceptual_roughness: 1.0, // If alpha is supported on text we need to change this alpha_mode: AlphaMode::Opaque, double_sided: false, diff --git a/src/objects/input/sk_controller.rs b/src/objects/input/sk_controller.rs index e81cc2e..cd53201 100644 --- a/src/objects/input/sk_controller.rs +++ b/src/objects/input/sk_controller.rs @@ -27,7 +27,6 @@ use bevy_mod_xr::{ session::{XrPreDestroySession, XrSessionCreated, XrSessionCreatedEvent}, spaces::{XrPrimaryReferenceSpace, XrReferenceSpace, XrSpace}, }; -use bevy_sk::vr_materials::PbrMaterial; use color_eyre::eyre::Result; use glam::{Affine3A, Mat4, Vec2, Vec3}; use openxr::{Action, ActiveActionSet, SpaceLocationFlags}; diff --git a/src/objects/input/sk_hand.rs b/src/objects/input/sk_hand.rs index 218fea6..0b934bb 100644 --- a/src/objects/input/sk_hand.rs +++ b/src/objects/input/sk_hand.rs @@ -8,7 +8,7 @@ use crate::nodes::{ spatial::Spatial, }; use crate::objects::{ObjectHandle, SpatialRef, Tracked}; -use crate::{DbusConnection, ObjectRegistryRes, PreFrameWait}; +use crate::{BevyMaterial, DbusConnection, ObjectRegistryRes, PreFrameWait}; use bevy::prelude::Transform as BevyTransform; use bevy::prelude::*; use bevy_mod_openxr::helper_traits::{ToQuat, ToVec3}; @@ -18,7 +18,6 @@ use bevy_mod_xr::hands::{HandBone, HandSide, XrHandBoneEntities, XrHandBoneRadiu use bevy_mod_xr::session::{XrPreDestroySession, XrSessionCreated}; use bevy_mod_xr::spaces::{XrPrimaryReferenceSpace, XrSpaceLocationFlags}; use bevy_sk::hand::GRADIENT_TEXTURE_HANDLE; -use bevy_sk::vr_materials::PbrMaterial; use color_eyre::eyre::Result; use glam::{Mat4, Quat, Vec3}; use openxr::{HandJointLocation, SpaceLocationFlags}; @@ -44,7 +43,7 @@ fn update_hands( session: Option>, state: Option>, ref_space: Option>, - mut materials: ResMut>, + mut materials: ResMut>, mut joint_query: Query<( &mut BevyTransform, &mut XrSpaceLocationFlags, @@ -116,7 +115,7 @@ fn update_hand_material( (Entity, &HandSide), ( With, - With>, + With>, Without, ), >, @@ -137,7 +136,7 @@ fn update_hand_material( fn setup( connection: Res, mut cmds: Commands, - mut materials: ResMut>, + mut materials: ResMut>, ) { tokio::task::spawn({ let connection = connection.clone(); @@ -186,13 +185,13 @@ pub struct SkHand { tracked: ObjectHandle, tracker: Option, captured: bool, - material: Handle, + material: Handle, } impl SkHand { pub fn new( connection: &Connection, side: HandSide, - materials: &mut Assets, + materials: &mut Assets, ) -> Result { let (palm_spatial, palm_object) = SpatialRef::create( connection, @@ -219,11 +218,11 @@ impl SkHand { let datamap = Datamap::from_typed(HandDatamap::default())?; let input = InputMethod::add_to(&node.0, hand, datamap)?; - let material = materials.add(PbrMaterial { - color: Srgba::new(1.0, 1.0, 1.0, 1.0).into(), + let material = materials.add(BevyMaterial { + base_color: Srgba::new(1.0, 1.0, 1.0, 1.0).into(), alpha_mode: AlphaMode::Blend, - diffuse_texture: Some(GRADIENT_TEXTURE_HANDLE), - roughness: 1.0, + base_color_texture: Some(GRADIENT_TEXTURE_HANDLE), + perceptual_roughness: 1.0, ..default() }); Ok(SkHand { @@ -255,7 +254,7 @@ impl SkHand { fn update( &mut self, joints: Option<&openxr::HandJointLocations>, - materials: &mut ResMut>, + materials: &mut ResMut>, ) { // TODO: use the hand data source ext let real_hand = true; @@ -330,9 +329,9 @@ impl SkHand { *self.input.datamap.lock() = Datamap::from_typed(&self.datamap).unwrap(); let captured = self.capture_manager.capture.upgrade().is_some(); if captured && !self.captured { - materials.get_mut(&self.material).unwrap().color = Srgba::rgb(0., 1., 0.75).into(); + materials.get_mut(&self.material).unwrap().base_color = Srgba::rgb(0., 1., 0.75).into(); } else if self.captured && !captured { - materials.get_mut(&self.material).unwrap().color = Srgba::rgb(1., 1.0, 1.0).into(); + materials.get_mut(&self.material).unwrap().base_color = Srgba::rgb(1., 1.0, 1.0).into(); } self.captured = captured; }