Fmt.

Author: tychedelia

crates/processing_pyo3/examples/gltf_load.py

@@ -23,16 +23,16 @@ def draw():
     global frame
     t = frame * 0.02
 
-    radius = 150.0
+    radius = 1.5
     lx = math.cos(t) * radius
-    ly = 150.0
+    ly = 1.5
     lz = math.sin(t) * radius
     light.position(lx, ly, lz)
-    light.look_at(0.0, 80.0, 0.0)
+    light.look_at(0.0, 0.8, 0.0)
 
-    r = math.sin(t * 0.7) * 0.5 + 0.5
-    g = math.sin(t * 0.7 + 2.0) * 0.5 + 0.5
-    b = math.sin(t * 0.7 + 4.0) * 0.5 + 0.5
+    r = math.sin(t * 8.0) * 0.5 + 0.5
+    g = math.sin(t * 8.0 + 2.0) * 0.5 + 0.5
+    b = math.sin(t * 8.0 + 4.0) * 0.5 + 0.5
     duck_mat.set_float4("base_color", r, g, b, 1.0)
 
     background(25)

crates/processing_pyo3/src/gltf.rs

@@ -33,13 +33,12 @@ impl Gltf {
     }
 
     pub fn camera(&self, index: usize) -> PyResult<()> {
-        gltf_camera(self.entity, index)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+        gltf_camera(self.entity, index).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     pub fn light(&self, index: usize) -> PyResult<Light> {
-        let entity = gltf_light(self.entity, index)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        let entity =
+            gltf_light(self.entity, index).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
         Ok(Light { entity })
     }
 }
@@ -48,7 +47,7 @@ impl Gltf {
 #[pyo3(pass_module)]
 pub fn load_gltf(module: &Bound<'_, PyModule>, path: &str) -> PyResult<Gltf> {
     let graphics = get_graphics(module)?;
-    let entity = gltf_load(graphics.entity, path)
-        .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+    let entity =
+        gltf_load(graphics.entity, path).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
     Ok(Gltf { entity })
 }

crates/processing_render/src/gltf.rs

@@ -6,10 +6,10 @@ use bevy::{
         AssetPath, LoadState, handle_internal_asset_events,
         io::{AssetSourceId, embedded::GetAssetServer},
     },
+    camera::visibility::RenderLayers,
     ecs::system::RunSystemOnce,
     gltf::{Gltf, GltfMeshName},
     prelude::*,
-    camera::visibility::RenderLayers,
     scene::SceneSpawner,
 };
 
@@ -52,10 +52,7 @@ fn block_on_load(world: &mut World, load_state: impl Fn(&World) -> LoadState) ->
 }
 
 fn compute_global_transform(world: &World, entity: Entity) -> Transform {
-    let local = world
-        .get::<Transform>(entity)
-        .copied()
-        .unwrap_or_default();
+    let local = world.get::<Transform>(entity).copied().unwrap_or_default();
     match world.get::<ChildOf>(entity) {
         Some(child_of) => {
             let parent_global = compute_global_transform(world, child_of.parent());
@@ -99,14 +96,12 @@ pub fn load(
 
     // we spawn the scene in to the world in a blocking fashion so that bevy runs all
     // its hooks for the gltf, ex creating standard material instances
-    let instance_id =
-        world.resource_scope(|world, mut spawner: Mut<SceneSpawner>| {
-            spawner
-                .spawn_sync(world, &scene_handle)
-                .map_err(|e| ProcessingError::GltfLoadError(format!("Scene spawn failed: {e}")))
-        })?;
+    let instance_id = world.resource_scope(|world, mut spawner: Mut<SceneSpawner>| {
+        spawner
+            .spawn_sync(world, &scene_handle)
+            .map_err(|e| ProcessingError::GltfLoadError(format!("Scene spawn failed: {e}")))
+    })?;
 
-    
     // we have to remove the existing cameras from the scene -- the user can request to set *this*
     // graphics to a camera, but the scenes cameras should not exist
     {
@@ -144,7 +139,7 @@ pub fn geometry(
 
     let (mesh_handle, global_transform) = {
         let spawner = world.resource::<SceneSpawner>();
-        
+
         // find the mesh with the given name component that bevy added post-spawn
         // name is derived from gltf node or computed
         let mesh_entity = spawner
@@ -248,17 +243,10 @@ pub fn material_names(In(gltf_entity): In<Entity>, world: &mut World) -> Result<
     let gltf = gltf_assets
         .get(&gltf_handle)
         .ok_or_else(|| ProcessingError::GltfLoadError("GLTF asset not found".into()))?;
-    Ok(gltf
-        .named_materials
-        .keys()
-        .map(|k| k.to_string())
-        .collect())
+    Ok(gltf.named_materials.keys().map(|k| k.to_string()).collect())
 }
 
-pub fn camera(
-    In((gltf_entity, index)): In<(Entity, usize)>,
-    world: &mut World,
-) -> Result<()> {
+pub fn camera(In((gltf_entity, index)): In<(Entity, usize)>, world: &mut World) -> Result<()> {
     let gltf_handle = world
         .get::<GltfHandle>(gltf_entity)
         .ok_or(ProcessingError::InvalidEntity)?;
@@ -324,10 +312,7 @@ pub fn camera(
     Ok(())
 }
 
-pub fn light(
-    In((gltf_entity, index)): In<(Entity, usize)>,
-    world: &mut World,
-) -> Result<Entity> {
+pub fn light(In((gltf_entity, index)): In<(Entity, usize)>, world: &mut World) -> Result<Entity> {
     let gltf_handle = world
         .get::<GltfHandle>(gltf_entity)
         .ok_or(ProcessingError::InvalidEntity)?;

crates/processing_render/src/render/mod.rs

@@ -319,14 +319,13 @@ pub fn flush_draw_commands(
 
                     let z_offset = -(batch.draw_index as f32 * 0.001);
                     let mut transform = state.transform.to_bevy_transform();
-                    
+
                     // if the "source" geometry was parented in a gltf scene, we need to make sure that
                     // we apply the parent transform here to ensure the correct final transform
                     // TODO: think about how hierarchies should work, especially for retained
                     if let Some(nt) = node_transform {
-                        transform = Transform::from_matrix(
-                            transform.to_matrix() * nt.0.to_matrix(),
-                        );
+                        transform =
+                            Transform::from_matrix(transform.to_matrix() * nt.0.to_matrix());
                     }
                     transform.translation.z += z_offset;