JsonmodelLoader

jsonmodel_loader.rs

#[derive(Default)]
pub struct JsonmodelFormatLoader;

impl AssetLoader for JsonmodelFormatLoader {
    fn load<'a>(
        &'a self,
        bytes: &'a [u8],
        load_context: &'a mut bevy::asset::LoadContext,
    ) -> bevy::asset::BoxedFuture<'a, anyhow::Result<(), anyhow::Error>> {
        Box::pin(async move {
            let unpacked = match UnpackedCosmeticBinary::from_bytes(bytes) {
                Ok(v) => v,
                Err(e) => {
                    eprintln!("{:#?}", e);
                    anyhow::bail!("{e:?}");
                }
            };

            let mut world = World::default();

            let mut meshes = vec![];
            let mut materials = vec![];

            let mut spawner = world.spawn();

            match unpacked.model {
                Some(CosmeticModel {
                    name,
                    model:
                        McbeModel {
                            format_version,
                            minecraft_geometry,
                        },
                }) => {
                    for mcbe_model_loader::Definition { description, bones } in minecraft_geometry {
                        for mcbe_model_loader::Bone {
                            name,
                            pivot,
                            parent,
                            cubes,
                        } in bones
                        {
                            for (
                                cube_index,
                                mcbe_model_loader::Cube {
                                    origin,
                                    size,
                                    uv:
                                        mcbe_model_loader::UV {
                                            north,
                                            east,
                                            south,
                                            west,
                                            up,
                                            down,
                                        },
                                },
                            ) in cubes.iter().enumerate()
                            {
                                let cube_id = format!("{name}-{cube_index}");
                                let mesh = load_context.set_labeled_asset(
                                    cube_id.as_str(),
                                    LoadedAsset::new(Mesh::from(shape::Box::new(
                                        size.x, size.y, size.z,
                                    ))),
                                );
                                meshes.push(mesh.clone());
                                let material = load_context.set_labeled_asset(
                                    format!("{cube_id}-material").as_str(),
                                    LoadedAsset::new(Color::rgb(1.0, 0.0, 0.0).into()),
                                );
                                materials.push(material.clone());
                                let transform = Transform::identity();
                                spawner.insert_bundle(PbrBundle {
                                    mesh,
                                    material,
                                    transform,
                                    ..Default::default()
                                    // global_transform: todo!(),
                                    // visibility: todo!(),
                                    // computed_visibility: todo!(),
                                });
                            }
                        }
                    }
                }
                None => {
                    unimplemented!("this is a cape")
                }
            }
            let scene =
                load_context.set_labeled_asset("scene", LoadedAsset::new(Scene::new(world)));
            load_context.set_default_asset(bevy::asset::LoadedAsset::new(super::Jsonmodel {
                meshes,
                scene,
                materials,
            }));
            Ok(())
        })
    }

    fn extensions(&self) -> &'static [&'static str] {
        JSON_COSMETIC_FILE_ALL_EXTENSIONS
    }
}