feat(Blenvy:Bevy):

* removed file_watcher feature, should be user settable
 * added root blueprintInfo path to the list of assets to watch for hot reload
 * removed settable aabb calculation: they will now always be done
 * added "export_registry" setting to be able to disable registry export for wasm & co (automate later)
 * minor tweaks
 * cleanups
This commit is contained in:
kaosat.dev 2024-07-22 00:26:02 +02:00
parent e54d41ca5c
commit 382759d71f
11 changed files with 143 additions and 100 deletions

View File

@ -14,7 +14,7 @@ license = "MIT OR Apache-2.0"
workspace = true workspace = true
[dependencies] [dependencies]
bevy = { version = "0.14", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf", "file_watcher"] } bevy = { version = "0.14", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] } #, "file_watcher"
serde = "1.0.188" serde = "1.0.188"
ron = "0.8.1" ron = "0.8.1"
serde_json = "1.0.108" serde_json = "1.0.108"

View File

@ -37,8 +37,7 @@ pub fn compute_scene_aabbs(
} }
} }
for entity in other_entities.iter() { for entity in other_entities.iter() {
println!("already got AABB"); commands.entity(entity).insert(BlueprintReadyForFinalizing);
commands.entity(entity).insert(BlueprintReadyForFinalizing); // FIXME ! Yikes !!
} }
} }

View File

@ -87,10 +87,14 @@ pub struct AnimationMarkerReached {
///////////////////// /////////////////////
/// triggers events when a given animation marker is reached for BLUEPRINT animations /// triggers events when a given animation marker is reached for BLUEPRINT animations
pub fn trigger_blueprint_animation_markers_events( pub fn trigger_blueprint_animation_markers_events(
animation_data: Query<(Entity, &BlueprintAnimationPlayerLink, &BlueprintAnimationInfosLink, &BlueprintAnimations)>, animation_data: Query<(
Entity,
&BlueprintAnimationPlayerLink,
&BlueprintAnimationInfosLink,
&BlueprintAnimations,
)>,
// FIXME: annoying hiearchy issue yet again: the Markers & AnimationInfos are stored INSIDE the blueprint, so we need to access them differently // FIXME: annoying hiearchy issue yet again: the Markers & AnimationInfos are stored INSIDE the blueprint, so we need to access them differently
animation_infos: Query<(&AnimationInfos, &AnimationMarkers)>, animation_infos: Query<(&AnimationInfos, &AnimationMarkers)>,
animation_players: Query<&AnimationPlayer>, animation_players: Query<&AnimationPlayer>,
@ -99,9 +103,7 @@ pub fn trigger_blueprint_animation_markers_events(
animation_clips: Res<Assets<AnimationClip>>, animation_clips: Res<Assets<AnimationClip>>,
) { ) {
for (entity, player_link, infos_link, animations) in animation_data.iter() { for (entity, player_link, infos_link, animations) in animation_data.iter() {
for (animation_name, node_index) in animations.named_indices.iter() { for (animation_name, node_index) in animations.named_indices.iter() {
let animation_player = animation_players.get(player_link.0).unwrap(); let animation_player = animation_players.get(player_link.0).unwrap();
let (animation_infos, animation_markers) = animation_infos.get(infos_link.0).unwrap(); let (animation_infos, animation_markers) = animation_infos.get(infos_link.0).unwrap();
@ -109,21 +111,24 @@ pub fn trigger_blueprint_animation_markers_events(
if let Some(animation) = animation_player.animation(*node_index) { if let Some(animation) = animation_player.animation(*node_index) {
// animation.speed() // animation.speed()
// animation.completions() // animation.completions()
if let Some(animation_clip_handle) = animations.named_animations.get(animation_name) { if let Some(animation_clip_handle) =
animations.named_animations.get(animation_name)
{
if let Some(animation_clip) = animation_clips.get(animation_clip_handle) { if let Some(animation_clip) = animation_clips.get(animation_clip_handle) {
let animation_length_seconds = animation_clip.duration(); let animation_length_seconds = animation_clip.duration();
let animation_length_frames = animation_infos // FIXME: horribly inneficient let animation_length_frames =
animation_infos // FIXME: horribly inneficient
.animations .animations
.iter() .iter()
.find(|anim| &anim.name == animation_name) .find(|anim| &anim.name == animation_name)
.unwrap() .unwrap()
.frames_length; .frames_length;
// TODO: we also need to take playback speed into account // TODO: we also need to take playback speed into account
let time_in_animation = animation.elapsed() let time_in_animation = animation.elapsed()
- (animation.completions() as f32) * animation_length_seconds; - (animation.completions() as f32) * animation_length_seconds;
let frame_seconds = (animation_length_frames / animation_length_seconds) let frame_seconds = (animation_length_frames
/ animation_length_seconds)
* time_in_animation; * time_in_animation;
// println!("frame seconds {}", frame_seconds); // println!("frame seconds {}", frame_seconds);
let frame = frame_seconds.ceil() as u32; // FIXME , bad hack let frame = frame_seconds.ceil() as u32; // FIXME , bad hack
@ -133,7 +138,10 @@ pub fn trigger_blueprint_animation_markers_events(
if matching_animation_marker.contains_key(&frame) { if matching_animation_marker.contains_key(&frame) {
let matching_markers_per_frame = let matching_markers_per_frame =
matching_animation_marker.get(&frame).unwrap(); matching_animation_marker.get(&frame).unwrap();
println!("FOUND A MARKER {:?} at frame {}", matching_markers_per_frame, frame); println!(
"FOUND A MARKER {:?} at frame {}",
matching_markers_per_frame, frame
);
// FIXME: complete hack-ish solution , otherwise this can fire multiple times in a row, depending on animation length , speed , etc // FIXME: complete hack-ish solution , otherwise this can fire multiple times in a row, depending on animation length , speed , etc
let diff = frame as f32 - frame_seconds; let diff = frame as f32 - frame_seconds;
if diff < 0.1 { if diff < 0.1 {
@ -155,7 +163,6 @@ pub fn trigger_blueprint_animation_markers_events(
} }
} }
/// triggers events when a given animation marker is reached for INSTANCE animations /// triggers events when a given animation marker is reached for INSTANCE animations
pub fn trigger_instance_animation_markers_events( pub fn trigger_instance_animation_markers_events(
animation_infos: Query<( animation_infos: Query<(
@ -178,9 +185,10 @@ pub fn trigger_instance_animation_markers_events(
let animation_player = animation_players.get(player_link.0).unwrap(); let animation_player = animation_players.get(player_link.0).unwrap();
if animation_player.animation_is_playing(*node_index) { if animation_player.animation_is_playing(*node_index) {
if let Some(animation) = animation_player.animation(*node_index) { if let Some(animation) = animation_player.animation(*node_index) {
if let Some(animation_clip_handle) = animations.named_animations.get(animation_name) { if let Some(animation_clip_handle) =
animations.named_animations.get(animation_name)
{
if let Some(animation_clip) = animation_clips.get(animation_clip_handle) { if let Some(animation_clip) = animation_clips.get(animation_clip_handle) {
println!("helooo") println!("helooo")
} }
} }

View File

@ -37,7 +37,6 @@ pub struct BlueprintAllAssets {
pub assets: Vec<BlueprintAsset>, pub assets: Vec<BlueprintAsset>,
} }
//////////////////////// ////////////////////////
/// ///
/// flag component, usually added when a blueprint is loaded /// flag component, usually added when a blueprint is loaded

View File

@ -1,26 +1,23 @@
use crate::{BlueprintAssetsLoadState, BlueprintAssetsLoaded, BlueprintInfo, BlueprintInstanceReady, BlueprintSpawning, FromBlueprint, SpawnBlueprint, SubBlueprintsSpawnTracker}; use crate::{
BlueprintAssetsLoadState, BlueprintAssetsLoaded, BlueprintInfo, BlueprintInstanceReady,
BlueprintSpawning, FromBlueprint, SpawnBlueprint, SubBlueprintsSpawnTracker,
};
use bevy::asset::AssetEvent; use bevy::asset::AssetEvent;
use bevy::prelude::*; use bevy::prelude::*;
use bevy::scene::SceneInstance; use bevy::scene::SceneInstance;
use bevy::utils::hashbrown::HashMap; use bevy::utils::hashbrown::HashMap;
/// Resource mapping asset paths (ideally untyped ids, but more complex) to a list of blueprint instance entity ids /// Resource mapping asset paths (ideally untyped ids, but more complex) to a list of blueprint instance entity ids
#[derive(Debug, Clone, Resource, Default)] #[derive(Debug, Clone, Resource, Default)]
pub(crate) struct AssetToBlueprintInstancesMapper{ pub(crate) struct AssetToBlueprintInstancesMapper {
// pub(crate) untyped_id_to_blueprint_entity_ids: HashMap<UntypedAssetId, Vec<Entity>> // pub(crate) untyped_id_to_blueprint_entity_ids: HashMap<UntypedAssetId, Vec<Entity>>
pub(crate) untyped_id_to_blueprint_entity_ids: HashMap<String, Vec<Entity>> pub(crate) untyped_id_to_blueprint_entity_ids: HashMap<String, Vec<Entity>>,
} }
pub(crate) fn react_to_asset_changes( pub(crate) fn react_to_asset_changes(
mut gltf_events: EventReader<AssetEvent<Gltf>>, // FIXME: Problem: we need to react to any asset change, not just gltf files ! mut gltf_events: EventReader<AssetEvent<Gltf>>, // FIXME: Problem: we need to react to any asset change, not just gltf files !
// mut untyped_events: EventReader<AssetEvent<LoadedUntypedAsset>>, // mut untyped_events: EventReader<AssetEvent<LoadedUntypedAsset>>,
blueprint_assets: Query<( blueprint_assets: Query<(Entity, Option<&Name>, &BlueprintInfo, Option<&Children>)>,
Entity,
Option<&Name>,
&BlueprintInfo,
Option<&Children>,
)>,
blueprint_children_entities: Query<&FromBlueprint>, //=> can only be used if the entites are tagged blueprint_children_entities: Query<&FromBlueprint>, //=> can only be used if the entites are tagged
assets_to_blueprint_instances: Res<AssetToBlueprintInstancesMapper>, assets_to_blueprint_instances: Res<AssetToBlueprintInstancesMapper>,
all_parents: Query<&Parent>, all_parents: Query<&Parent>,
@ -28,7 +25,6 @@ pub(crate) fn react_to_asset_changes(
asset_server: Res<AssetServer>, asset_server: Res<AssetServer>,
mut commands: Commands, mut commands: Commands,
) { ) {
let mut respawn_candidates: Vec<&Entity> = vec![]; let mut respawn_candidates: Vec<&Entity> = vec![];
@ -44,15 +40,19 @@ pub(crate) fn react_to_asset_changes(
// let bla = untyped.unwrap().id(); // let bla = untyped.unwrap().id();
// asset_server.get // asset_server.get
// in order to avoid respawn both a parent & a child , which would crash Bevy, we do things in two steps // in order to avoid respawn both a parent & a child , which would crash Bevy, we do things in two steps
if let Some(entities) = assets_to_blueprint_instances.untyped_id_to_blueprint_entity_ids.get(&asset_path.to_string()) { if let Some(entities) = assets_to_blueprint_instances
.untyped_id_to_blueprint_entity_ids
.get(&asset_path.to_string())
{
for entity in entities.iter() { for entity in entities.iter() {
println!("matching blueprint instance {}", entity); // println!("matching blueprint instance {}", entity);
// disregard entities that are already (re) spawning // disregard entities that are already (re) spawning
if !respawn_candidates.contains(&entity) && blueprint_assets.get(*entity).is_ok() && spawning_blueprints.get(*entity).is_err() if !respawn_candidates.contains(&entity)
&& blueprint_assets.get(*entity).is_ok()
&& spawning_blueprints.get(*entity).is_err()
{ {
respawn_candidates.push(entity); respawn_candidates.push(entity);
} }
} }
} }
} }
@ -65,26 +65,28 @@ pub(crate) fn react_to_asset_changes(
// TODO: improve this, very inneficient // TODO: improve this, very inneficient
let mut retained_candidates: Vec<Entity> = vec![]; let mut retained_candidates: Vec<Entity> = vec![];
'outer: for entity in respawn_candidates.iter() { 'outer: for entity in respawn_candidates.iter() {
for parent in all_parents.iter_ancestors(**entity){ for parent in all_parents.iter_ancestors(**entity) {
for ent in respawn_candidates.iter() { for ent in respawn_candidates.iter() {
if **ent == parent { if **ent == parent {
if ! retained_candidates.contains(&parent) { if !retained_candidates.contains(&parent) {
retained_candidates.push(parent); retained_candidates.push(parent);
} }
continue 'outer; continue 'outer;
} }
} }
} }
if ! retained_candidates.contains(entity) { if !retained_candidates.contains(entity) {
retained_candidates.push(**entity); retained_candidates.push(**entity);
} }
} }
// println!("respawn candidates {:?}", respawn_candidates); // println!("respawn candidates {:?}", respawn_candidates);
for retained in retained_candidates.iter() { for retained in retained_candidates.iter() {
println!("retained {}", retained); // println!("retained {}", retained);
if let Ok((entity, entity_name, _blueprint_info, children)) = blueprint_assets.get(*retained) { if let Ok((entity, entity_name, _blueprint_info, children)) =
println!("HOLY MOLY IT DETECTS !!, now respawn {:?}", entity_name); blueprint_assets.get(*retained)
{
info!("Change detected !!, now respawn {:?}", entity_name);
// TODO: only remove those that are "in blueprint" // TODO: only remove those that are "in blueprint"
if children.is_some() { if children.is_some() {

View File

@ -53,7 +53,12 @@ pub(crate) fn inject_materials(
material_found = Some(material); material_found = Some(material);
} else { } else {
let model_handle: Handle<Gltf> = asset_server.load(material_info.path.clone()); // FIXME: kinda weird now let model_handle: Handle<Gltf> = asset_server.load(material_info.path.clone()); // FIXME: kinda weird now
let mat_gltf = assets_gltf.get(model_handle.id()).unwrap_or_else(|| panic!("materials file {} should have been preloaded", material_info.path)); let mat_gltf = assets_gltf.get(model_handle.id()).unwrap_or_else(|| {
panic!(
"materials file {} should have been preloaded",
material_info.path
)
});
if mat_gltf if mat_gltf
.named_materials .named_materials
.contains_key(&material_info.name as &str) .contains_key(&material_info.name as &str)

View File

@ -50,19 +50,14 @@ impl Default for BluePrintBundle {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
/// Plugin for gltf blueprints /// Plugin for gltf blueprints
pub struct BlueprintsPlugin { pub struct BlueprintsPlugin {
/// Automatically generate aabbs for the blueprints root objects
pub aabbs: bool,
} }
impl Default for BlueprintsPlugin { impl Default for BlueprintsPlugin {
fn default() -> Self { fn default() -> Self {
Self { aabbs: false } Self { }
} }
} }
fn aabbs_enabled(blenvy_config: Res<BlenvyConfig>) -> bool {
blenvy_config.aabbs
}
fn hot_reload(watching_for_changes: Res<WatchingForChanges>) -> bool { fn hot_reload(watching_for_changes: Res<WatchingForChanges>) -> bool {
// println!("hot reload ? {}", watching_for_changes.0); // println!("hot reload ? {}", watching_for_changes.0);
@ -131,7 +126,7 @@ impl Plugin for BlueprintsPlugin {
blueprints_cleanup_spawned_scene, blueprints_cleanup_spawned_scene,
// beyond this point : post processing to finalize blueprint instances // beyond this point : post processing to finalize blueprint instances
inject_materials, inject_materials,
compute_scene_aabbs, // .run_if(aabbs_enabled), compute_scene_aabbs,
blueprints_finalize_instances, blueprints_finalize_instances,
) )
.chain() .chain()

View File

@ -4,7 +4,10 @@ use bevy::{gltf::Gltf, prelude::*, scene::SceneInstance, utils::hashbrown::HashM
use serde_json::Value; use serde_json::Value;
use crate::{ use crate::{
AnimationInfos, AssetLoadTracker, AssetToBlueprintInstancesMapper, BlenvyConfig, BlueprintAnimationInfosLink, BlueprintAnimationPlayerLink, BlueprintAnimations, BlueprintAssets, BlueprintAssetsLoadState, BlueprintAssetsLoaded, BlueprintAssetsNotLoaded, InstanceAnimationInfosLink, InstanceAnimationPlayerLink, InstanceAnimations, WatchingForChanges AnimationInfos, AssetLoadTracker, AssetToBlueprintInstancesMapper, BlueprintAnimationInfosLink,
BlueprintAnimationPlayerLink, BlueprintAnimations, BlueprintAssets, BlueprintAssetsLoadState,
BlueprintAssetsLoaded, BlueprintAssetsNotLoaded, InstanceAnimationInfosLink,
InstanceAnimationPlayerLink, InstanceAnimations, WatchingForChanges,
}; };
/// this is a flag component for our levels/game world /// this is a flag component for our levels/game world
@ -89,7 +92,6 @@ pub enum BlueprintEvent {
}, },
} }
#[derive(Component, Reflect, Debug, Default)] #[derive(Component, Reflect, Debug, Default)]
#[reflect(Component)] #[reflect(Component)]
/// component gets added when a blueprint starts spawning, removed when spawning is completely done /// component gets added when a blueprint starts spawning, removed when spawning is completely done
@ -97,7 +99,6 @@ pub struct BlueprintSpawning;
use gltf::Gltf as RawGltf; use gltf::Gltf as RawGltf;
/* /*
Overview of the Blueprint Spawning process Overview of the Blueprint Spawning process
- Blueprint Load Assets - Blueprint Load Assets
@ -115,10 +116,7 @@ Overview of the Blueprint Spawning process
*/ */
pub(crate) fn blueprints_prepare_spawn( pub(crate) fn blueprints_prepare_spawn(
blueprint_instances_to_spawn: Query< blueprint_instances_to_spawn: Query<(Entity, &BlueprintInfo), Added<SpawnBlueprint>>,
(Entity, &BlueprintInfo),
Added<SpawnBlueprint>,
>,
mut commands: Commands, mut commands: Commands,
asset_server: Res<AssetServer>, asset_server: Res<AssetServer>,
// for hot reload // for hot reload
@ -153,9 +151,9 @@ pub(crate) fn blueprints_prepare_spawn(
/* prefetch attempt */ /* prefetch attempt */
let gltf = RawGltf::open(format!("assets/{}", blueprint_info.path)).unwrap(); let gltf = RawGltf::open(format!("assets/{}", blueprint_info.path)).unwrap();
for scene in gltf.scenes() { for scene in gltf.scenes() {
if let Some(scene_extras) = scene.extras().clone() if let Some(scene_extras) = scene.extras().clone() {
{ let lookup: HashMap<String, Value> =
let lookup: HashMap<String, Value> = serde_json::from_str(scene_extras.get()).unwrap(); serde_json::from_str(scene_extras.get()).unwrap();
if lookup.contains_key("BlueprintAssets") { if lookup.contains_key("BlueprintAssets") {
let assets_raw = &lookup["BlueprintAssets"]; let assets_raw = &lookup["BlueprintAssets"];
//println!("ASSETS RAW {}", assets_raw); //println!("ASSETS RAW {}", assets_raw);
@ -183,18 +181,56 @@ pub(crate) fn blueprints_prepare_spawn(
// Only do this if hot reload is enabled // Only do this if hot reload is enabled
if watching_for_changes.0 { if watching_for_changes.0 {
if !assets_to_blueprint_instances.untyped_id_to_blueprint_entity_ids.contains_key(&path_id) { if !assets_to_blueprint_instances
assets_to_blueprint_instances.untyped_id_to_blueprint_entity_ids.insert(path_id.clone(), vec![]); .untyped_id_to_blueprint_entity_ids
.contains_key(&path_id)
{
assets_to_blueprint_instances
.untyped_id_to_blueprint_entity_ids
.insert(path_id.clone(), vec![]);
} }
// only insert if not already present in mapping // only insert if not already present in mapping
if !assets_to_blueprint_instances.untyped_id_to_blueprint_entity_ids[&path_id].contains(&entity) { if !assets_to_blueprint_instances.untyped_id_to_blueprint_entity_ids
[&path_id]
.contains(&entity)
{
// println!("adding mapping between {} and entity {:?}", path_id, all_names.get(entity)); // println!("adding mapping between {} and entity {:?}", path_id, all_names.get(entity));
assets_to_blueprint_instances.untyped_id_to_blueprint_entity_ids.get_mut(&path_id).unwrap().push(entity); assets_to_blueprint_instances
.untyped_id_to_blueprint_entity_ids
.get_mut(&path_id)
.unwrap()
.push(entity);
}
}
}
}
} }
} }
// Only do this if hot reload is enabled
// TODO: should this be added to the list of "all assets" on the blender side instead
if watching_for_changes.0 {
// also add the root blueprint info to the list of hot reload items
if !assets_to_blueprint_instances
.untyped_id_to_blueprint_entity_ids
.contains_key(&blueprint_info.path)
{
assets_to_blueprint_instances
.untyped_id_to_blueprint_entity_ids
.insert(blueprint_info.path.clone(), vec![]);
} }
} // only insert if not already present in mapping
if !assets_to_blueprint_instances.untyped_id_to_blueprint_entity_ids
[&blueprint_info.path]
.contains(&entity)
{
// println!("adding mapping between {} and entity {:?}", path_id, all_names.get(entity));
assets_to_blueprint_instances
.untyped_id_to_blueprint_entity_ids
.get_mut(&blueprint_info.path)
.unwrap()
.push(entity);
} }
} }
@ -243,7 +279,9 @@ pub(crate) fn blueprints_check_assets_loading(
let loaded = asset_server.is_loaded_with_dependencies(asset_id); let loaded = asset_server.is_loaded_with_dependencies(asset_id);
let mut failed = false; let mut failed = false;
if let bevy::asset::LoadState::Failed(_) = asset_server.load_state(asset_id) { failed = true } if let bevy::asset::LoadState::Failed(_) = asset_server.load_state(asset_id) {
failed = true
}
tracker.loaded = loaded || failed; tracker.loaded = loaded || failed;
if loaded || failed { if loaded || failed {
loaded_amount += 1; loaded_amount += 1;
@ -267,12 +305,10 @@ pub(crate) fn blueprints_check_assets_loading(
commands commands
.entity(entity) .entity(entity)
.insert(BlueprintAssetsLoaded) .insert(BlueprintAssetsLoaded)
.remove::<BlueprintAssetsNotLoaded>() .remove::<BlueprintAssetsNotLoaded>();
;
if !watching_for_changes.0 { if !watching_for_changes.0 {
commands.entity(entity) commands.entity(entity).remove::<BlueprintAssetsLoadState>(); //we REMOVE this component when in hot reload is OFF, as we
.remove::<BlueprintAssetsLoadState>(); //we REMOVE this component when in hot reload is OFF, as we
} }
} }
} }
@ -556,12 +592,11 @@ pub(crate) fn blueprints_cleanup_spawned_scene(
all_names: Query<&Name>, all_names: Query<&Name>,
) { ) {
for (original, children, original_children, name, animations) in for (original, children, original_children, name, animations) in blueprint_scenes.iter() {
blueprint_scenes.iter()
{
info!("Cleaning up spawned scene {:?}", name); info!("Cleaning up spawned scene {:?}", name);
if children.len() == 0 { // TODO: investigate, Honestly not sure if this issue from Bevy 0.12 is still present at all anymore if children.len() == 0 {
// TODO: investigate, Honestly not sure if this issue from Bevy 0.12 is still present at all anymore
warn!("timing issue ! no children found, please restart your bevy app (bug being investigated)"); warn!("timing issue ! no children found, please restart your bevy app (bug being investigated)");
continue; continue;
} }
@ -582,7 +617,6 @@ pub(crate) fn blueprints_cleanup_spawned_scene(
commands.entity(child).insert(FromBlueprint); // we do this here in order to avoid doing it to normal children commands.entity(child).insert(FromBlueprint); // we do this here in order to avoid doing it to normal children
} }
// copy components into from blueprint instance's blueprint_root_entity to original entity // copy components into from blueprint instance's blueprint_root_entity to original entity
commands.add(CopyComponents { commands.add(CopyComponents {
source: blueprint_root_entity, source: blueprint_root_entity,
@ -632,14 +666,10 @@ pub(crate) fn blueprints_cleanup_spawned_scene(
all_names.get(child), all_names.get(child),
all_names.get(original) all_names.get(original)
); );
commands commands.entity(original).insert(
.entity(original)
.insert(
//BlueprintAnimationPlayerLink(bla), //BlueprintAnimationPlayerLink(bla),
BlueprintAnimationInfosLink(child) BlueprintAnimationInfosLink(child),
) );
;
} else { } else {
for parent in all_parents.iter_ancestors(child) { for parent in all_parents.iter_ancestors(child) {
if animation_players.get(parent).is_ok() { if animation_players.get(parent).is_ok() {
@ -663,8 +693,9 @@ pub(crate) fn blueprints_cleanup_spawned_scene(
)); ));
} }
if with_animation_infos.get(parent).is_ok() { if with_animation_infos.get(parent).is_ok() {
commands.entity(child).insert(InstanceAnimationInfosLink(parent)); commands
.entity(child)
.insert(InstanceAnimationInfosLink(parent));
} }
} }
} }

View File

@ -65,7 +65,6 @@ fn components_string_to_components(
ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap(); ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
println!("serialized Component {}", serialized); println!("serialized Component {}", serialized);
*/ */
debug!("component data ron string {}", ron_string); debug!("component data ron string {}", ron_string);
let mut deserializer = ron::Deserializer::from_str(ron_string.as_str()) let mut deserializer = ron::Deserializer::from_str(ron_string.as_str())
.expect("deserialzer should have been generated from string"); .expect("deserialzer should have been generated from string");

View File

@ -13,13 +13,13 @@ pub use blueprints::*;
#[derive(Clone, Resource)] #[derive(Clone, Resource)]
pub struct BlenvyConfig { pub struct BlenvyConfig {
// registry // registry
pub(crate) export_registry: bool,
pub(crate) registry_save_path: PathBuf, pub(crate) registry_save_path: PathBuf,
pub(crate) registry_component_filter: SceneFilter, pub(crate) registry_component_filter: SceneFilter,
#[allow(dead_code)] #[allow(dead_code)]
pub(crate) registry_resource_filter: SceneFilter, pub(crate) registry_resource_filter: SceneFilter,
// blueprints // blueprints
pub(crate) aabbs: bool,
pub(crate) aabb_cache: HashMap<String, Aabb>, // cache for aabbs pub(crate) aabb_cache: HashMap<String, Aabb>, // cache for aabbs
pub(crate) materials_cache: HashMap<String, Handle<StandardMaterial>>, // cache for materials pub(crate) materials_cache: HashMap<String, Handle<StandardMaterial>>, // cache for materials
@ -31,14 +31,12 @@ pub struct BlenvyConfig {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
/// Plugin for gltf blueprints /// Plugin for gltf blueprints
pub struct BlenvyPlugin { pub struct BlenvyPlugin {
pub export_registry: bool,
pub registry_save_path: PathBuf, pub registry_save_path: PathBuf,
pub registry_component_filter: SceneFilter, pub registry_component_filter: SceneFilter,
pub registry_resource_filter: SceneFilter, pub registry_resource_filter: SceneFilter,
/// Automatically generate aabbs for the blueprints root objects
pub aabbs: bool,
// for save & load // for save & load
pub save_component_filter: SceneFilter, pub save_component_filter: SceneFilter,
pub save_resource_filter: SceneFilter, pub save_resource_filter: SceneFilter,
@ -47,10 +45,10 @@ pub struct BlenvyPlugin {
impl Default for BlenvyPlugin { impl Default for BlenvyPlugin {
fn default() -> Self { fn default() -> Self {
Self { Self {
export_registry: true,
registry_save_path: PathBuf::from("registry.json"), // relative to assets folder registry_save_path: PathBuf::from("registry.json"), // relative to assets folder
registry_component_filter: SceneFilter::default(), registry_component_filter: SceneFilter::default(),
registry_resource_filter: SceneFilter::default(), registry_resource_filter: SceneFilter::default(),
aabbs: false,
save_component_filter: SceneFilter::default(), save_component_filter: SceneFilter::default(),
save_resource_filter: SceneFilter::default(), save_resource_filter: SceneFilter::default(),
@ -66,17 +64,17 @@ impl Plugin for BlenvyPlugin {
BlueprintsPlugin::default(), BlueprintsPlugin::default(),
)) ))
.insert_resource(BlenvyConfig { .insert_resource(BlenvyConfig {
export_registry: self.export_registry,
registry_save_path: self.registry_save_path.clone(), registry_save_path: self.registry_save_path.clone(),
registry_component_filter: self.registry_component_filter.clone(), registry_component_filter: self.registry_component_filter.clone(),
registry_resource_filter: self.registry_resource_filter.clone(), registry_resource_filter: self.registry_resource_filter.clone(),
aabbs: self.aabbs,
aabb_cache: HashMap::new(), aabb_cache: HashMap::new(),
materials_cache: HashMap::new(), materials_cache: HashMap::new(),
save_component_filter: self.save_component_filter.clone(), save_component_filter: self.save_component_filter.clone(),
save_resource_filter: self.save_resource_filter.clone() save_resource_filter: self.save_resource_filter.clone(),
}); });
} }
} }

View File

@ -6,10 +6,12 @@ pub use export_types::*;
use bevy::{ use bevy::{
app::Startup, app::Startup,
asset::AssetPlugin, asset::AssetPlugin,
prelude::{App, Plugin, Resource}, prelude::{App, IntoSystemConfigs, Plugin, Res, Resource},
scene::SceneFilter, scene::SceneFilter,
}; };
use crate::BlenvyConfig;
pub struct ExportRegistryPlugin { pub struct ExportRegistryPlugin {
pub component_filter: SceneFilter, pub component_filter: SceneFilter,
pub resource_filter: SceneFilter, pub resource_filter: SceneFilter,
@ -26,9 +28,14 @@ impl Default for ExportRegistryPlugin {
} }
} }
fn export_registry(blenvy_config: Res<BlenvyConfig>) -> bool {
// TODO: add detection of Release builds, wasm, and android in order to avoid exporting registry in those cases
blenvy_config.export_registry
}
impl Plugin for ExportRegistryPlugin { impl Plugin for ExportRegistryPlugin {
fn build(&self, app: &mut App) { fn build(&self, app: &mut App) {
app.register_asset_root().add_systems(Startup, export_types); app.register_asset_root().add_systems(Startup, export_types.run_if(export_registry));
} }
} }