StardustXR/protostar
1
0
Fork 0
Code Issues 5 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

more optimisation whatever idk really know what I am doing

Browse Source
This commit is contained in:
MayaTheShy
2025-11-02 00:32:46 -04:00
parent 4a761f27dd
commit 3cc68df2d9
2 changed files with 277 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
hexagon_launcher/src/main.rs
View File

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
use single::{APP_SIZE, App, BTN_COLOR, BTN_SELECTED_COLOR, MODEL_SCALE}; use single::{APP_SIZE, App, BTN_COLOR, BTN_SELECTED_COLOR, MODEL_SCALE};
use stardust_xr_asteroids::{ use stardust_xr_asteroids::{
ClientState, CustomElement, Element, Migrate, Reify, Transformable, client, ClientState, CustomElement, Element, Migrate, Reify, Transformable, client,
elements::{Button, Grabbable, Model, ModelPart}, elements::{Button, Grabbable, Model, ModelPart, PointerMode, Spatial},
}; };
use stardust_xr_fusion::{ use stardust_xr_fusion::{
drawable::MaterialParameter, drawable::MaterialParameter,
@@ -17,6 +17,8 @@ use stardust_xr_fusion::{
project_local_resources, project_local_resources,
spatial::Transform, spatial::Transform,
}; };
use stardust_xr_fusion::values::ResourceID;
use std::path::PathBuf;
use std::f32::consts::{FRAC_PI_2, PI}; use std::f32::consts::{FRAC_PI_2, PI};
use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::atomic::AtomicU64; use std::sync::atomic::AtomicU64;
@@ -80,6 +82,16 @@ pub struct HexagonLauncher {
#[serde(skip)] #[serde(skip)]
/// cached world coordinates for each app hex /// cached world coordinates for each app hex
positions: Vec<[f32; 3]>, positions: Vec<[f32; 3]>,
#[serde(skip)]
/// lightweight immutable snapshots for fast per-frame reify
snapshots: Vec<Snapshot>,
}
#[derive(Clone)]
struct Snapshot {
name: String,
cached_texture: Option<ResourceID>,
cached_gltf: Option<PathBuf>,
} }
impl Default for HexagonLauncher { impl Default for HexagonLauncher {
@@ -90,6 +102,7 @@ impl Default for HexagonLauncher {
rot: Quat::IDENTITY.into(), rot: Quat::IDENTITY.into(),
apps: Vec::new(), apps: Vec::new(),
positions: Vec::new(), positions: Vec::new(),
snapshots: Vec::new(),
} }
} }
} }
@@ -133,11 +146,13 @@ impl ClientState for HexagonLauncher {
self.apps.par_iter().for_each(|app| { self.apps.par_iter().for_each(|app| {
// GLTF path warm: call Model::direct once (parser/cache warm-up) // GLTF path warm: call Model::direct once (parser/cache warm-up)
if let Some(gltf_path) = app.cached_gltf.get() { if let Some(gltf_path) = app.cached_gltf.get() {
let _ = Model::direct(gltf_path.to_string_lossy().to_string()); if let Ok(builder) = Model::direct(gltf_path.to_string_lossy().to_string()) {
let _ = CustomElement::<HexagonLauncher>::build(builder);
}
} else if let Some(tex) = app.cached_texture.get() { } else if let Some(tex) = app.cached_texture.get() {
// Raster icon path warm: build the lightweight namespaced model // Raster icon path warm: build the lightweight namespaced model
// with the cached texture so material/texture creation happens now. // with the cached texture so material/texture creation happens now.
let _ = Model::namespaced("protostar", "hexagon/hexagon") let builder = Model::namespaced("protostar", "hexagon/hexagon")
.part(ModelPart::new("Hex").mat_param( .part(ModelPart::new("Hex").mat_param(
"color", "color",
MaterialParameter::Color(crate::BTN_COLOR), MaterialParameter::Color(crate::BTN_COLOR),
@@ -145,10 +160,21 @@ impl ClientState for HexagonLauncher {
.part(ModelPart::new("Icon").mat_param( .part(ModelPart::new("Icon").mat_param(
"diffuse", "diffuse",
MaterialParameter::Texture(tex.clone()), MaterialParameter::Texture(tex.clone()),
)) ));
.build(); let _ = CustomElement::<HexagonLauncher>::build(builder);
} }
}); });
// build immutable lightweight snapshots used during reify
self.snapshots = self
.apps
.iter()
.map(|a| Snapshot {
name: a.app.name().unwrap_or_default(),
cached_texture: a.cached_texture.get().cloned(),
cached_gltf: a.cached_gltf.get().cloned(),
})
.collect();
} }
} }
impl Reify for HexagonLauncher { impl Reify for HexagonLauncher {
@@ -245,16 +271,56 @@ impl Reify for HexagonLauncher {
.iter() .iter()
.enumerate() .enumerate()
.take(take_n) .take(take_n)
.map(|(i, app)| { .map(|(i, _app)| {
Spatial::default() // use snapshot instead of reify_substate (cheap, immutable)
.pos(self.positions[i]) let snap = self.snapshots[i].clone();
.build() let pos = self.positions[i];
.child(app.reify_substate(move |state: &mut HexagonLauncher| { // build spatial + cheap model from snapshot (no per-app state access)
// log & count access to per-app substate let mut spatial = Spatial::default().pos(pos).build();
APP_REIFY_COUNT.fetch_add(1, Ordering::Relaxed); +
tracing::trace!(index = i, "accessing app substate"); + // attach model from snapshot (gltf preferred, else namespaced + texture)
state.apps.get_mut(i) + if let Some(gltf) = snap.cached_gltf {
})) + if let Ok(builder) = Model::direct(gltf.to_string_lossy().to_string()) {
+ spatial = spatial.child(builder.transform(Transform::from_rotation_scale(
+ Quat::from_rotation_x(PI / 2.0) * Quat::from_rotation_y(PI),
+ [MODEL_SCALE; 3],
+ )).build());
+ }
+ } else {
+ let mut mb = Model::namespaced("protostar", "hexagon/hexagon")
+ .transform(Transform::from_rotation_scale(
+ Quat::from_rotation_x(PI / 2.0) * Quat::from_rotation_y(PI),
+ [MODEL_SCALE; 3],
+ ))
+ .part(ModelPart::new("Hex").mat_param(
+ "color",
+ MaterialParameter::Color(if self.open {
+ BTN_SELECTED_COLOR
+ } else {
+ BTN_COLOR
+ }),
+ ));
+ if let Some(tex) = snap.cached_texture {
+ mb = mb.part(ModelPart::new("Icon").mat_param(
+ "diffuse",
+ MaterialParameter::Texture(tex),
+ ));
+ }
+ spatial = spatial.child(mb.build());
+ }
+
+ // attach a Button that mutates real state when used (captures index)
+ spatial.child(
+ Button::new(move |state: &mut HexagonLauncher| {
+ // example: toggle open / or launch the app via state.apps[i]
+ // keep mutation here, but we avoid doing this per-frame.
+ // if you need to launch: state.apps[i].launch(...);
+ tracing::debug!(index = i, "app button pressed");
+ })
+ .pos([0.0, 0.0, 0.0])
+ .size([0.01; 2])
+ .build(),
+ )
}) })
}) })
.into_iter() .into_iter()

95
single/src/app.rs
View File

@@ -7,14 +7,12 @@ use stardust_xr_asteroids::elements::{
Grabbable, Lines, Model, ModelPart, PointerMode, Text, line_from_points, Grabbable, Lines, Model, ModelPart, PointerMode, Text, line_from_points,
}; };
use stardust_xr_asteroids::{CustomElement, Element, Reify, Transformable}; use stardust_xr_asteroids::{CustomElement, Element, Reify, Transformable};
use stardust_xr_fusion::drawable::{TextBounds, TextFit}; use stardust_xr_fusion::drawable::{TextBounds, TextFit, MaterialParameter, XAlign, YAlign};
use stardust_xr_fusion::node::NodeError; use stardust_xr_fusion::fields::{CylinderShape, Shape};
use stardust_xr_fusion::spatial::Transform;
use stardust_xr_fusion::values::ResourceID; use stardust_xr_fusion::values::ResourceID;
use stardust_xr_fusion::{ use stardust_xr_fusion::node::NodeError;
drawable::{MaterialParameter, XAlign, YAlign}, use std::path::PathBuf;
fields::{CylinderShape, Shape},
spatial::Transform,
};
use std::f32::consts::{FRAC_PI_2, PI}; use std::f32::consts::{FRAC_PI_2, PI};
use std::sync::OnceLock; use std::sync::OnceLock;
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
@@ -27,6 +25,12 @@ pub struct App {
pub app: Application, pub app: Application,
#[serde(skip)] #[serde(skip)]
icon: OnceLock<Icon>, icon: OnceLock<Icon>,
// cached lightweight handles derived from the icon:
// - for PNG/raster icons we cache a ResourceID::Direct for the texture
#[serde(skip)]
pub cached_texture: OnceLock<ResourceID>,
#[serde(skip)]
pub cached_gltf: OnceLock<PathBuf>,
pos: Vector3<f32>, pos: Vector3<f32>,
rot: Quaternion<f32>, rot: Quaternion<f32>,
#[serde(skip)] #[serde(skip)]
@@ -38,6 +42,8 @@ impl App {
Ok(App { Ok(App {
app, app,
icon: OnceLock::default(), icon: OnceLock::default(),
cached_texture: OnceLock::default(),
cached_gltf: OnceLock::default(),
pos: [0.0; 3].into(), pos: [0.0; 3].into(),
rot: Quat::IDENTITY.into(), rot: Quat::IDENTITY.into(),
launched: AtomicBool::new(false), launched: AtomicBool::new(false),
@@ -45,47 +51,76 @@ impl App {
} }
pub fn load_icon(&self) { pub fn load_icon(&self) {
if self.icon.get().is_none() // Only attempt to load/process the icon once
&& let Some(icon) = self if self.icon.get().is_none() {
if let Some(icon) = self
.app .app
.icon(64, true) .icon(64, true)
.and_then(|i| i.cached_process(64).ok()) .and_then(|i| i.cached_process(64).ok())
{ {
let _ = self.icon.set(icon); // store raw icon
let _ = self.icon.set(icon.clone());
// cache lightweight handles derived from the icon so reify can be cheap
match &icon.icon_type {
IconType::Gltf => {
// cache the gltf path (PathBuf) so we don't call Model::direct() discovery per-reify
let _ = self.cached_gltf.set(icon.path.clone());
}
IconType::Png => {
// cache a ResourceID::Direct for the texture
let _ = self
.cached_texture
.set(ResourceID::Direct(icon.path.clone()));
}
_ => {}
}
}
} }
} }
// Helper functions for creating app components // Helper functions for creating app components
fn create_model(&self) -> impl Element<Self> { fn create_model(&self) -> impl Element<Self> {
match self.icon.get().as_ref().map(|i| (i.icon_type.clone(), i)) { // prefer cached gltf path if present (avoids repeated Model::direct parsing)
Some((IconType::Gltf, icon)) => Model::direct(icon.path.clone()) if let Some(gltf_path) = self.cached_gltf.get() {
.unwrap() // Model::direct accepts a string/path — convert PathBuf to String here to be safe
if let Ok(builder) = Model::direct(gltf_path.to_string_lossy().to_string()) {
return builder
.transform(Transform::from_rotation_scale( .transform(Transform::from_rotation_scale(
Quat::from_rotation_x(PI / 2.0) * Quat::from_rotation_y(PI), Quat::from_rotation_x(PI / 2.0) * Quat::from_rotation_y(PI),
[MODEL_SCALE; 3], [MODEL_SCALE; 3],
)) ))
.build(), .build();
other => { }
let model = Model::namespaced("protostar", "hexagon/hexagon") }
// fallback / raster icon path: use a namespaced hex model and attach a cached texture
let mut model = Model::namespaced("protostar", "hexagon/hexagon")
.transform(Transform::from_rotation_scale( .transform(Transform::from_rotation_scale(
Quat::from_rotation_x(PI / 2.0) * Quat::from_rotation_y(PI), Quat::from_rotation_x(PI / 2.0) * Quat::from_rotation_y(PI),
[APP_SIZE / 2.0; 3], [APP_SIZE / 2.0; 3],
)) ))
.part( .part(ModelPart::new("Hex").mat_param(
ModelPart::new("Hex") "color",
.mat_param("color", MaterialParameter::Color(DEFAULT_HEX_COLOR)), MaterialParameter::Color(DEFAULT_HEX_COLOR),
); ));
match other { if let Some(tex) = self.cached_texture.get() {
Some((IconType::Png, icon)) => model.part(ModelPart::new("Icon").mat_param( model = model.part(ModelPart::new("Icon").mat_param(
"diffuse",
MaterialParameter::Texture(tex.clone()),
));
} else if let Some(icon) = self.icon.get() {
// fallback to using icon path directly if caching didn't happen for some reason
if let IconType::Png = icon.icon_type {
model = model.part(ModelPart::new("Icon").mat_param(
"diffuse", "diffuse",
MaterialParameter::Texture(ResourceID::Direct(icon.path.clone())), MaterialParameter::Texture(ResourceID::Direct(icon.path.clone())),
)), ));
_ => model,
}
.build()
} }
} }
model.build()
} }
} }
impl Reify for App { impl Reify for App {
@@ -101,6 +136,10 @@ impl Reify for App {
let length = converted.length(); let length = converted.length();
let direction = converted.normalize_or_zero(); let direction = converted.normalize_or_zero();
// cull models that are far away to avoid heavy model builds every frame
const CULL_DISTANCE: f32 = 4.0;
let should_render_model = length <= CULL_DISTANCE;
Lines::new([line_from_points(vec![ Lines::new([line_from_points(vec![
Vec3::from([0.0; 3]), Vec3::from([0.0; 3]),
(length < ACTIVATION_DISTANCE) as u32 as f32 (length < ACTIVATION_DISTANCE) as u32 as f32
@@ -121,7 +160,6 @@ impl Reify for App {
move |state: &mut Self| { move |state: &mut Self| {
let pos_vec = Vec3::from(state.pos); let pos_vec = Vec3::from(state.pos);
if pos_vec.length() > ACTIVATION_DISTANCE { if pos_vec.length() > ACTIVATION_DISTANCE {
// state.app.launch(launch_space)
state.launched.store(true, Ordering::Relaxed); state.launched.store(true, Ordering::Relaxed);
} else { } else {
state.pos = [0.0; 3].into(); state.pos = [0.0; 3].into();
@@ -134,7 +172,8 @@ impl Reify for App {
.max_distance(0.05) .max_distance(0.05)
.reparentable(false) .reparentable(false)
.build() .build()
.child(self.create_model()) // only build the (potentially expensive) model element when the hex is close enough
.children(should_render_model.then(|| self.create_model()).into_iter())
.children(self.launched.load(Ordering::Relaxed).then(|| { .children(self.launched.load(Ordering::Relaxed).then(|| {
AppLauncher::new(&self.app) AppLauncher::new(&self.app)
.done(|state: &mut Self| { .done(|state: &mut Self| {