MayaTheShy/Starworld
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor: simplify reify implementation in BridgeState by removing cube line generation

Browse Source
This commit is contained in:
MayaTheShy
2025-11-08 21:43:26 -05:00
parent 0e61648354
commit f2fd4b86f1
1 changed files with 4 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
bridge/src/lib.rs
View File

@@ -69,133 +69,11 @@ impl ClientState for BridgeState {
impl Reify for BridgeState { impl Reify for BridgeState {
fn reify(&self) -> impl ast::Element<Self> { fn reify(&self) -> impl ast::Element<Self> {
use stardust_xr_fusion::values::color::rgba_linear; eprintln!("[bridge/reify] Reifying {} nodes - START", self.nodes.len());
use stardust_xr_fusion::drawable::{Line, LinePoint};
use stardust_xr_fusion::values::Vector3;
eprintln!("[bridge/reify] Reifying {} nodes", self.nodes.len()); // Temporary: just return empty PlaySpace to test
eprintln!("[bridge/reify] Returning empty PlaySpace");
// Helper function to create cube lines with proper Line/LinePoint structs PlaySpace.build()
fn create_cube_lines(half_size: glam::Vec3, color: stardust_xr_fusion::values::Color, thickness: f32) -> Vec<Line> {
let mut lines = Vec::new();
// Create a dense grid of lines to make it look more solid
let steps = 8; // More lines = more solid appearance
for i in 0..=steps {
let t = (i as f32) / (steps as f32) * 2.0 - 1.0;
// Lines parallel to X axis
for j in 0..=steps {
let u = (j as f32) / (steps as f32) * 2.0 - 1.0;
lines.push(Line {
points: vec![
LinePoint {
point: Vector3 { x: -half_size.x, y: t * half_size.y, z: u * half_size.z },
thickness,
color,
},
LinePoint {
point: Vector3 { x: half_size.x, y: t * half_size.y, z: u * half_size.z },
thickness,
color,
},
],
cyclic: false,
});
}
// Lines parallel to Y axis
for j in 0..=steps {
let u = (j as f32) / (steps as f32) * 2.0 - 1.0;
lines.push(Line {
points: vec![
LinePoint {
point: Vector3 { x: t * half_size.x, y: -half_size.y, z: u * half_size.z },
thickness,
color,
},
LinePoint {
point: Vector3 { x: t * half_size.x, y: half_size.y, z: u * half_size.z },
thickness,
color,
},
],
cyclic: false,
});
}
// Lines parallel to Z axis
for j in 0..=steps {
let u = (j as f32) / (steps as f32) * 2.0 - 1.0;
lines.push(Line {
points: vec![
LinePoint {
point: Vector3 { x: t * half_size.x, y: u * half_size.y, z: -half_size.z },
thickness,
color,
},
LinePoint {
point: Vector3 { x: t * half_size.x, y: u * half_size.y, z: half_size.z },
thickness,
color,
},
],
cyclic: false,
});
}
}
lines
}
// Root playspace. Create appropriate visuals per entity type
let children = self.nodes.iter().filter_map(|(id, node)| {
// Skip nodes with zero dimensions (like the root node)
let dims = glam::Vec3::from(node.dimensions);
if dims.length() < 0.001 {
eprintln!("[bridge/reify] Skipping node {} (zero dimensions)", id);
return None;
}
eprintln!("[bridge/reify] Creating visual for node {} type={} dims={:?}", id, node.entity_type, dims);
// Decompose transform into TRS
let (scale, rot, trans) = node.transform.to_scale_rotation_translation();
// Use entity dimensions if available, otherwise use transform scale
let vis_scale = if dims.length() > 0.001 {
dims
} else {
scale
};
// Use entity color if set
let node_color = rgba_linear!(node.color[0], node.color[1], node.color[2], node.color[3]);
// Create transform - convert glam Vec3/Quat to [f32; 3]/[f32; 4] which implement Into
let trans_array = [trans.x, trans.y, trans.z];
let rot_array = [rot.x, rot.y, rot.z, rot.w];
let scale_array = [vis_scale.x, vis_scale.y, vis_scale.z];
let transform = Transform::from_translation_rotation_scale(trans_array, rot_array, scale_array);
// Create a dense cube mesh for a more solid appearance
let half_size = glam::Vec3::splat(0.5); // Lines will be scaled by transform
let cube_lines = create_cube_lines(half_size, node_color, 0.005);
// Entity types: 0=Unknown, 1=Box, 2=Sphere, 3=Model
// For now, render all as dense wireframe cubes (which we know works)
Some((
*id,
Spatial::default()
.transform(transform)
.build()
.child(Lines::new(cube_lines).build())
))
});
PlaySpace
.build()
.stable_children(children)
} }
} }