Initial project import
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-06-05 21:44:45 -04:00
commit f29712d158
259 files changed
+52069

No files matched your search

+247
View File
@@ -0,0 +1,247 @@
//! Actor kind inference (migration only) and save-time validation.
use bevy::ecs::world::EntityRef;
use bevy::prelude::*;
use crate::{
ActorKind, LevelObject, LightDesc, ModelRef, ObjectiveMarker, PlayerSpawn,
PostProcessVolumeDesc, PrefabInstance, PrefabRef, Primitive, StaticMeshRenderer, TeamSpawn,
TriggerVolume, WeaponSpawn,
};
/// One-shot deterministic kind from authoring components (scene migration only).
pub fn infer_actor_kind(entity: EntityRef<'_>) -> Option<ActorKind> {
if entity.get::<LevelObject>().is_none() {
return None;
}
if entity.get::<PlayerSpawn>().is_some() {
return Some(ActorKind::PlayerSpawn);
}
if entity.get::<WeaponSpawn>().is_some() {
return Some(ActorKind::WeaponSpawn);
}
if entity.get::<TriggerVolume>().is_some() {
return Some(ActorKind::TriggerVolume);
}
if entity.get::<PostProcessVolumeDesc>().is_some() {
return Some(ActorKind::PostProcessVolume);
}
if entity.get::<TeamSpawn>().is_some() {
return Some(ActorKind::TeamSpawn);
}
if entity.get::<ObjectiveMarker>().is_some() {
return Some(ActorKind::Objective);
}
if entity.get::<LightDesc>().is_some() {
return Some(ActorKind::Light);
}
if entity.get::<Primitive>().is_some() || entity.get::<StaticMeshRenderer>().is_some() {
return Some(ActorKind::StaticMesh);
}
if entity.get::<ModelRef>().is_some() {
return Some(ActorKind::ImportedModel);
}
if entity.get::<PrefabRef>().is_some() || entity.get::<PrefabInstance>().is_some() {
return Some(ActorKind::PrefabAnchor);
}
Some(ActorKind::Empty)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ActorValidationError {
MissingActorKind,
MissingTransform,
StaticMeshMissingPrimitive,
StaticMeshHasLight,
StaticMeshHasModelRef,
ImportedModelMissingModelRef,
ImportedModelHasPrimitive,
ImportedModelHasStaticMeshRenderer,
LightMissingLightDesc,
LightHasPrimitive,
LightHasModelRef,
LightHasStaticMeshRenderer,
PostProcessVolumeInvalidHalfExtents,
PostProcessVolumeInvalidBlendDistance,
PostProcessVolumeInvalidOverrideScalar,
PostProcessVolumeMissingDesc,
}
fn is_finite_positive(v: f32) -> bool {
v.is_finite() && v > 0.0
}
fn is_finite_non_negative(v: f32) -> bool {
v.is_finite() && v >= 0.0
}
/// Validates authoring component sets for a level object before save or play.
pub fn validate_actor(entity: EntityRef<'_>) -> Result<(), ActorValidationError> {
if entity.get::<LevelObject>().is_none() {
return Ok(());
}
let Some(kind) = entity.get::<ActorKind>() else {
return Err(ActorValidationError::MissingActorKind);
};
if entity.get::<Transform>().is_none() {
return Err(ActorValidationError::MissingTransform);
}
match kind {
ActorKind::StaticMesh => {
let has_static_mesh_renderer = entity
.get::<StaticMeshRenderer>()
.is_some_and(|renderer| renderer.slots.iter().any(|slot| slot.mesh.is_resolved()));
if entity.get::<Primitive>().is_none() && !has_static_mesh_renderer {
return Err(ActorValidationError::StaticMeshMissingPrimitive);
}
if entity.get::<LightDesc>().is_some() {
return Err(ActorValidationError::StaticMeshHasLight);
}
if entity.get::<ModelRef>().is_some() {
return Err(ActorValidationError::StaticMeshHasModelRef);
}
}
ActorKind::ImportedModel => {
if entity.get::<ModelRef>().is_none() {
return Err(ActorValidationError::ImportedModelMissingModelRef);
}
if entity.get::<Primitive>().is_some() {
return Err(ActorValidationError::ImportedModelHasPrimitive);
}
if entity.get::<StaticMeshRenderer>().is_some() {
return Err(ActorValidationError::ImportedModelHasStaticMeshRenderer);
}
}
ActorKind::Light => {
if entity.get::<LightDesc>().is_none() {
return Err(ActorValidationError::LightMissingLightDesc);
}
if entity.get::<Primitive>().is_some() {
return Err(ActorValidationError::LightHasPrimitive);
}
if entity.get::<ModelRef>().is_some() {
return Err(ActorValidationError::LightHasModelRef);
}
if entity.get::<StaticMeshRenderer>().is_some() {
return Err(ActorValidationError::LightHasStaticMeshRenderer);
}
}
ActorKind::PostProcessVolume => {
let Some(desc) = entity.get::<PostProcessVolumeDesc>() else {
return Err(ActorValidationError::PostProcessVolumeMissingDesc);
};
if !is_finite_positive(desc.half_extents.x)
|| !is_finite_positive(desc.half_extents.y)
|| !is_finite_positive(desc.half_extents.z)
{
return Err(ActorValidationError::PostProcessVolumeInvalidHalfExtents);
}
if !is_finite_non_negative(desc.blend_distance) {
return Err(ActorValidationError::PostProcessVolumeInvalidBlendDistance);
}
let o = &desc.overrides;
if let Some(v) = o.exposure_ev100 {
if !v.is_finite() {
return Err(ActorValidationError::PostProcessVolumeInvalidOverrideScalar);
}
}
if let Some(v) = o.fog_density {
if !v.is_finite() || v < 0.0 {
return Err(ActorValidationError::PostProcessVolumeInvalidOverrideScalar);
}
}
}
ActorKind::Empty
| ActorKind::PrefabAnchor
| ActorKind::PlayerSpawn
| ActorKind::WeaponSpawn
| ActorKind::TriggerVolume
| ActorKind::TeamSpawn
| ActorKind::Objective => {}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::PostProcessVolumeDesc;
fn level_entity(world: &mut World, bundle: impl Bundle) -> Entity {
world
.spawn((LevelObject, Transform::default(), bundle))
.id()
}
#[test]
fn validate_static_mesh_ok() {
let mut world = World::new();
let e = level_entity(&mut world, (ActorKind::StaticMesh, Primitive::default()));
assert!(validate_actor(world.entity(e)).is_ok());
}
#[test]
fn validate_static_mesh_renderer_ok() {
let mut world = World::new();
let mut renderer = StaticMeshRenderer::default();
renderer.slots.push(crate::StaticMeshRendererEntry {
mesh: crate::StaticMeshAssetRef::new("asset-id", "Mesh0/Primitive0", "Crate"),
..Default::default()
});
let e = level_entity(&mut world, (ActorKind::StaticMesh, renderer));
assert!(validate_actor(world.entity(e)).is_ok());
}
#[test]
fn validate_static_mesh_rejects_light() {
let mut world = World::new();
let e = level_entity(
&mut world,
(
ActorKind::StaticMesh,
Primitive::default(),
LightDesc::default(),
),
);
assert_eq!(
validate_actor(world.entity(e)),
Err(ActorValidationError::StaticMeshHasLight)
);
}
#[test]
fn validate_post_process_volume_ok() {
let mut world = World::new();
let e = level_entity(
&mut world,
(
ActorKind::PostProcessVolume,
PostProcessVolumeDesc::default(),
),
);
assert!(validate_actor(world.entity(e)).is_ok());
}
#[test]
fn validate_post_process_volume_rejects_bad_extents() {
let mut world = World::new();
let e = level_entity(
&mut world,
(
ActorKind::PostProcessVolume,
PostProcessVolumeDesc {
half_extents: Vec3::ZERO,
..Default::default()
},
),
);
assert_eq!(
validate_actor(world.entity(e)),
Err(ActorValidationError::PostProcessVolumeInvalidHalfExtents)
);
}
}
File diff suppressed because it is too large. Load diff
+297
View File
@@ -0,0 +1,297 @@
//! Bevy lights from [`LightDesc`] authoring data.
use bevy::light::{CascadeShadowConfig, CascadeShadowConfigBuilder};
use bevy::prelude::*;
use settings::RenderingSettings;
use crate::{
inspector_component_active, AuthoringLightKind, InspectorOrder, LevelObject, LightDesc,
COMPONENT_LIGHT_DESC,
};
/// Legacy directional lux below this is treated as invalid (see ADR 0011).
pub const MIN_DIRECTIONAL_LUX: f32 = 1_000.0;
/// Documented outdoor default matching [`RenderingSettings`].
pub const DEFAULT_DIRECTIONAL_LUX: f32 = 100_000.0;
/// Builds cascaded shadow config from project rendering shadow fields (matches [`game_hot::spawn_sun`]).
pub fn cascade_config_from_rendering(rendering: &RenderingSettings) -> CascadeShadowConfig {
CascadeShadowConfigBuilder {
num_cascades: rendering.shadow_cascades as usize,
first_cascade_far_bound: rendering.shadow_first_cascade,
maximum_distance: rendering.shadow_max_distance,
..default()
}
.build()
}
#[allow(clippy::type_complexity)]
pub fn hydrate_lights(
mut commands: Commands,
settings: Res<settings::ProjectSettings>,
lights: Query<
(Entity, &LightDesc, Option<&InspectorOrder>),
(
With<LevelObject>,
Or<(
Added<LightDesc>,
Changed<LightDesc>,
Changed<InspectorOrder>,
)>,
),
>,
) {
let rendering = &settings.rendering;
for (entity, light, order) in &lights {
let mut entity_commands = commands.entity(entity);
strip_light_components(&mut entity_commands);
if !inspector_component_active(order, COMPONENT_LIGHT_DESC) {
continue;
}
insert_light_from_desc(&mut entity_commands, light, rendering);
}
}
pub(crate) fn strip_light_components(entity: &mut EntityCommands<'_>) {
entity
.remove::<PointLight>()
.remove::<SpotLight>()
.remove::<DirectionalLight>()
.remove::<CascadeShadowConfig>();
}
pub(crate) fn normalized_directional_lux(intensity: f32) -> f32 {
if intensity < MIN_DIRECTIONAL_LUX {
warn!(
"Directional LightDesc intensity {intensity:.1} lux is below {MIN_DIRECTIONAL_LUX}; \
using {DEFAULT_DIRECTIONAL_LUX} lux"
);
DEFAULT_DIRECTIONAL_LUX
} else {
intensity
}
}
/// Re-applies runtime lights when authoring [`LightDesc`] exists but hydration was stripped.
#[allow(clippy::type_complexity)]
pub fn reconcile_missing_runtime_lights(
mut commands: Commands,
settings: Res<settings::ProjectSettings>,
lights: Query<(Entity, &LightDesc, Option<&InspectorOrder>), With<LevelObject>>,
points: Query<(), With<PointLight>>,
spots: Query<(), With<SpotLight>>,
directionals: Query<(), With<DirectionalLight>>,
) {
let rendering = &settings.rendering;
for (entity, light, order) in &lights {
if !inspector_component_active(order, COMPONENT_LIGHT_DESC) {
continue;
}
let missing = match light.kind {
AuthoringLightKind::Point => !points.contains(entity),
AuthoringLightKind::Spot => !spots.contains(entity),
AuthoringLightKind::Directional => !directionals.contains(entity),
};
if !missing {
continue;
}
let mut entity_commands = commands.entity(entity);
strip_light_components(&mut entity_commands);
insert_light_from_desc(&mut entity_commands, light, rendering);
}
}
pub(crate) fn insert_light_from_desc(
entity: &mut EntityCommands<'_>,
light: &LightDesc,
rendering: &RenderingSettings,
) {
let color = light.color.to_color();
match light.kind {
AuthoringLightKind::Point => {
entity.insert((
PointLight {
color,
intensity: light.intensity,
range: light.range,
shadows_enabled: light.shadows,
..default()
},
Visibility::Visible,
));
}
AuthoringLightKind::Spot => {
entity.insert((
SpotLight {
color,
intensity: light.intensity,
range: light.range,
shadows_enabled: light.shadows,
outer_angle: light.outer_angle_deg.to_radians(),
inner_angle: light.inner_angle_deg.to_radians(),
..default()
},
Visibility::Visible,
));
}
AuthoringLightKind::Directional => {
entity.insert((
DirectionalLight {
color,
illuminance: normalized_directional_lux(light.intensity),
shadows_enabled: light.shadows,
..default()
},
Visibility::Visible,
));
if light.shadows {
entity.insert(cascade_config_from_rendering(rendering));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{AuthoringLightKind, ColorDesc, LevelObject, LightDesc};
use bevy::ecs::world::CommandQueue;
use settings::RenderingSettings;
#[test]
fn light_kind_swap_replaces_runtime_types() {
let mut world = World::new();
let mut queue = CommandQueue::default();
let entity = world.spawn(LevelObject).id();
let rendering = RenderingSettings::default();
let spot = LightDesc::for_kind(AuthoringLightKind::Spot);
{
let mut commands = Commands::new(&mut queue, &mut world);
let mut entity_commands = commands.entity(entity);
insert_light_from_desc(&mut entity_commands, &spot, &rendering);
}
queue.apply(&mut world);
assert!(world.get::<SpotLight>(entity).is_some());
let point = LightDesc::for_kind(AuthoringLightKind::Point);
queue = CommandQueue::default();
{
let mut commands = Commands::new(&mut queue, &mut world);
let mut entity_commands = commands.entity(entity);
strip_light_components(&mut entity_commands);
insert_light_from_desc(&mut entity_commands, &point, &rendering);
}
queue.apply(&mut world);
assert!(world.get::<PointLight>(entity).is_some());
assert!(world.get::<SpotLight>(entity).is_none());
}
#[test]
fn directional_shadows_insert_cascade_config() {
let mut world = World::new();
let mut queue = CommandQueue::default();
let entity = world.spawn(LevelObject).id();
let rendering = RenderingSettings::default();
let mut light = LightDesc::for_kind(AuthoringLightKind::Directional);
light.shadows = true;
{
let mut commands = Commands::new(&mut queue, &mut world);
let mut entity_commands = commands.entity(entity);
insert_light_from_desc(&mut entity_commands, &light, &rendering);
}
queue.apply(&mut world);
assert!(world.get::<DirectionalLight>(entity).is_some());
let cascades = world.get::<CascadeShadowConfig>(entity).unwrap();
let expected = cascade_config_from_rendering(&rendering);
assert_eq!(cascades.bounds.len(), expected.bounds.len());
assert_eq!(
cascades.bounds.last().copied(),
expected.bounds.last().copied()
);
assert!(world.get::<Visibility>(entity).is_some());
}
#[test]
fn scene_directional_cascades_match_project_shadow_settings() {
let mut rendering = RenderingSettings::default();
rendering.shadow_cascades = 3;
rendering.shadow_first_cascade = 12.0;
rendering.shadow_max_distance = 400.0;
let config = cascade_config_from_rendering(&rendering);
let expected = cascade_config_from_rendering(&rendering);
assert_eq!(config.bounds, expected.bounds);
assert_eq!(config.bounds.len(), 3);
}
#[test]
fn hydrated_point_and_spot_lights_insert_visibility() {
let mut world = World::new();
let mut queue = CommandQueue::default();
let point_entity = world.spawn(LevelObject).id();
let spot_entity = world.spawn(LevelObject).id();
let rendering = RenderingSettings::default();
{
let mut commands = Commands::new(&mut queue, &mut world);
insert_light_from_desc(
&mut commands.entity(point_entity),
&LightDesc::for_kind(AuthoringLightKind::Point),
&rendering,
);
insert_light_from_desc(
&mut commands.entity(spot_entity),
&LightDesc::for_kind(AuthoringLightKind::Spot),
&rendering,
);
}
queue.apply(&mut world);
assert!(world.get::<PointLight>(point_entity).is_some());
assert!(world.get::<Visibility>(point_entity).is_some());
assert!(world.get::<SpotLight>(spot_entity).is_some());
assert!(world.get::<Visibility>(spot_entity).is_some());
}
#[test]
fn point_light_default_casts_shadows() {
let light = LightDesc::for_kind(AuthoringLightKind::Point);
assert!(light.shadows);
}
#[test]
fn spot_angles_use_degrees_converted_to_radians() {
let light = LightDesc {
kind: AuthoringLightKind::Spot,
inner_angle_deg: 20.0,
outer_angle_deg: 35.0,
..LightDesc::for_kind(AuthoringLightKind::Spot)
};
assert!((light.inner_angle_deg.to_radians() - 20.0_f32.to_radians()).abs() < f32::EPSILON);
let _ = ColorDesc::srgb(1.0, 1.0, 1.0);
}
#[test]
fn low_directional_lux_is_clamped_at_hydration() {
assert_eq!(normalized_directional_lux(50.0), DEFAULT_DIRECTIONAL_LUX);
assert_eq!(normalized_directional_lux(100_000.0), 100_000.0);
}
#[test]
fn reconcile_missing_runtime_lights_restores_directional() {
let mut app = App::new();
app.add_plugins(MinimalPlugins);
app.insert_resource(settings::ProjectSettings::default());
app.add_systems(Update, reconcile_missing_runtime_lights);
let entity = app
.world_mut()
.spawn((
LevelObject,
LightDesc::for_kind(AuthoringLightKind::Directional),
))
.id();
app.update();
assert!(app.world().get::<DirectionalLight>(entity).is_some());
}
}
+92
View File
@@ -0,0 +1,92 @@
//! Standard materials from [`MaterialDesc`] authoring data.
use bevy::prelude::*;
use crate::{
asset_server_path, inspector_component_active, InspectorOrder, LevelObject, MaterialDesc,
MaterialShaderKind, Primitive, COMPONENT_MATERIAL_DESC,
};
#[allow(clippy::type_complexity)]
pub fn hydrate_materials(
mut commands: Commands,
asset_server: Res<AssetServer>,
mut materials: ResMut<Assets<StandardMaterial>>,
targets: Query<
(Entity, &MaterialDesc, Option<&InspectorOrder>),
(
With<LevelObject>,
With<Mesh3d>,
Or<(
Changed<MaterialDesc>,
Added<Mesh3d>,
Changed<Primitive>,
Changed<InspectorOrder>,
)>,
),
>,
) {
for (entity, desc, order) in &targets {
if !inspector_component_active(order, COMPONENT_MATERIAL_DESC) {
commands
.entity(entity)
.remove::<MeshMaterial3d<StandardMaterial>>();
continue;
}
let material = materials.add(material_from_desc(&asset_server, desc));
commands.entity(entity).insert(MeshMaterial3d(material));
}
}
pub fn material_from_desc(asset_server: &AssetServer, desc: &MaterialDesc) -> StandardMaterial {
StandardMaterial {
base_color: desc.base_color.to_color(),
metallic: desc.metallic,
perceptual_roughness: desc.roughness,
unlit: matches!(desc.shader.kind, MaterialShaderKind::Unlit),
base_color_texture: desc
.base_color_texture
.as_ref()
.map(|path| asset_server.load(asset_server_path(path))),
emissive: LinearRgba::rgb(
desc.emissive_color.r * desc.emissive_intensity,
desc.emissive_color.g * desc.emissive_intensity,
desc.emissive_color.b * desc.emissive_intensity,
),
emissive_texture: desc
.emissive_texture
.as_ref()
.map(|path| asset_server.load(asset_server_path(path))),
normal_map_texture: desc
.normal_map_texture
.as_ref()
.map(|path| asset_server.load(asset_server_path(path))),
metallic_roughness_texture: desc
.metallic_roughness_texture
.as_ref()
.map(|path| asset_server.load(asset_server_path(path))),
..default()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ColorDesc;
#[test]
fn emissive_desc_maps_to_standard_material() {
let mut app = App::new();
app.add_plugins((MinimalPlugins, AssetPlugin::default()));
let asset_server = app.world().resource::<AssetServer>();
let mut desc = MaterialDesc::default();
desc.emissive_color = ColorDesc::srgb(0.5, 0.25, 1.0);
desc.emissive_intensity = 1000.0;
let material = material_from_desc(asset_server, &desc);
assert_eq!(material.emissive.red, 500.0);
assert_eq!(material.emissive.green, 250.0);
assert_eq!(material.emissive.blue, 1000.0);
}
}
+324
View File
@@ -0,0 +1,324 @@
//! Generates runtime render/physics/light components from reflectable authoring data.
mod lights;
mod materials;
mod models;
mod physics;
mod prefabs;
mod primitives;
mod static_meshes;
pub mod strip;
mod visibility;
pub use lights::cascade_config_from_rendering;
pub use strip::{strip_hydrated, strip_hydrated_entity};
use bevy::ecs::system::SystemState;
use bevy::prelude::*;
use lights::{hydrate_lights, reconcile_missing_runtime_lights};
use materials::{hydrate_materials, material_from_desc};
use models::hydrate_models;
use physics::hydrate_physics;
use prefabs::hydrate_prefabs;
use primitives::{hydrate_primitives, primitive_mesh};
use static_meshes::{
hydrate_static_mesh_renderers, spawn_static_mesh_parts, HydratedStaticMeshPart,
StaticMeshArtifactCache,
};
use visibility::{init_editor_visibility_on_spawn, sync_editor_visibility};
use crate::{
inspector_component_active, ColliderDesc, EditorVisibility, InspectorOrder, LevelObject,
MaterialDesc, MaterialOverride, Primitive, StaticMeshRenderer, COMPONENT_COLLIDER_DESC,
COMPONENT_LIGHT_DESC, COMPONENT_MATERIAL_DESC, COMPONENT_PRIMITIVE,
COMPONENT_STATIC_MESH_RENDERER,
};
/// Registers hydration systems in deterministic order.
pub struct HydrationPlugin;
impl Plugin for HydrationPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<StaticMeshArtifactCache>()
.add_systems(
Update,
(
hydrate_primitives,
hydrate_materials,
hydrate_lights,
reconcile_missing_runtime_lights,
hydrate_static_mesh_renderers,
hydrate_models,
hydrate_prefabs,
hydrate_physics,
)
.chain(),
)
.add_systems(
Update,
(sync_editor_visibility, init_editor_visibility_on_spawn).chain(),
);
}
}
/// Runs the full hydration chain immediately (e.g. after scene load in the editor).
pub fn flush_level_object_hydration(world: &mut World) {
if !world.contains_resource::<StaticMeshArtifactCache>() {
world.insert_resource(StaticMeshArtifactCache::default());
}
let primitives: Vec<(Entity, Primitive)> = world
.query_filtered::<(Entity, &Primitive, Option<&InspectorOrder>), With<LevelObject>>()
.iter(world)
.filter(|(_, _, order)| inspector_component_active(*order, COMPONENT_PRIMITIVE))
.map(|(entity, primitive, _)| (entity, primitive.clone()))
.collect();
let material_targets: Vec<(Entity, MaterialDesc)> = world
.query_filtered::<(Entity, &MaterialDesc, Option<&InspectorOrder>), With<LevelObject>>()
.iter(world)
.filter(|(_, _, order)| inspector_component_active(*order, COMPONENT_MATERIAL_DESC))
.map(|(entity, desc, _)| (entity, desc.clone()))
.collect();
let static_mesh_entities_for_cleanup: Vec<Entity> = world
.query_filtered::<(Entity, &StaticMeshRenderer), With<LevelObject>>()
.iter(world)
.map(|(entity, _)| entity)
.collect();
let static_mesh_renderers: Vec<(
Entity,
StaticMeshRenderer,
Option<MaterialDesc>,
Option<MaterialOverride>,
Option<ColliderDesc>,
Option<InspectorOrder>,
)> = world
.query_filtered::<(
Entity,
&StaticMeshRenderer,
Option<&MaterialDesc>,
Option<&MaterialOverride>,
Option<&ColliderDesc>,
Option<&InspectorOrder>,
), With<LevelObject>>()
.iter(world)
.map(
|(entity, renderer, material, material_override, collider, order)| {
(
entity,
renderer.clone(),
material
.filter(|_| inspector_component_active(order, COMPONENT_MATERIAL_DESC))
.cloned(),
material_override.cloned(),
collider
.filter(|_| inspector_component_active(order, COMPONENT_COLLIDER_DESC))
.cloned(),
order.cloned(),
)
},
)
.filter(|(_, _, _, _, _, order)| {
inspector_component_active(order.as_ref(), COMPONENT_STATIC_MESH_RENDERER)
})
.collect();
let mut generated_static_mesh_parts = Vec::new();
for entity in &static_mesh_entities_for_cleanup {
if let Some(children) = world.get::<Children>(*entity) {
for child in children.iter() {
if world.get::<HydratedStaticMeshPart>(child).is_some() {
generated_static_mesh_parts.push(child);
}
}
}
}
let lights: Vec<(Entity, crate::LightDesc)> = world
.query_filtered::<(Entity, &crate::LightDesc, Option<&InspectorOrder>), With<LevelObject>>()
.iter(world)
.filter(|(_, _, order)| inspector_component_active(*order, COMPONENT_LIGHT_DESC))
.map(|(entity, light, _)| (entity, light.clone()))
.collect();
let visibility_targets: Vec<(Entity, EditorVisibility)> = world
.query_filtered::<(Entity, &EditorVisibility), With<LevelObject>>()
.iter(world)
.map(|(entity, vis)| (entity, *vis))
.collect();
let rendering = world
.get_resource::<settings::ProjectSettings>()
.map(|s| s.rendering.clone())
.unwrap_or_default();
let mut state: SystemState<(
Commands,
Res<AssetServer>,
ResMut<Assets<Mesh>>,
ResMut<Assets<StandardMaterial>>,
ResMut<StaticMeshArtifactCache>,
)> = SystemState::new(world);
{
let (mut commands, asset_server, mut meshes, mut materials, mut artifact_cache) =
state.get_mut(world);
for (entity, primitive) in primitives {
let mesh = meshes.add(primitive_mesh(&primitive));
commands.entity(entity).insert(Mesh3d(mesh));
}
for (entity, desc) in material_targets {
let material = materials.add(material_from_desc(&asset_server, &desc));
commands.entity(entity).insert(MeshMaterial3d(material));
}
for child in generated_static_mesh_parts {
commands.entity(child).despawn();
}
for (entity, renderer, material, material_override, collider, _) in &static_mesh_renderers {
spawn_static_mesh_parts(
&mut commands,
&asset_server,
&mut materials,
&mut artifact_cache,
*entity,
renderer,
material.as_ref(),
material_override.as_ref(),
collider.as_ref(),
);
}
for (entity, light) in lights {
let mut entity_commands = commands.entity(entity);
lights::strip_light_components(&mut entity_commands);
lights::insert_light_from_desc(&mut entity_commands, &light, &rendering);
}
}
state.apply(world);
for (entity, editor) in visibility_targets {
if let Some(mut vis) = world.get_mut::<Visibility>(entity) {
*vis = if editor.visible {
Visibility::Visible
} else {
Visibility::Hidden
};
}
}
}
#[cfg(test)]
mod tests {
use super::flush_level_object_hydration;
use super::strip::strip_hydrated_entity;
use crate::{
AuthoringLightKind, ColorDesc, InspectorOrder, LevelObject, LightDesc, MaterialDesc,
Primitive, COMPONENT_LIGHT_DESC,
};
use avian3d::prelude::*;
use bevy::prelude::*;
#[test]
fn flush_hydration_spawns_runtime_light_from_light_desc() {
let mut app = App::new();
app.add_plugins(MinimalPlugins);
app.add_plugins(AssetPlugin::default());
app.add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default());
app.init_asset::<Mesh>();
let entity = app
.world_mut()
.spawn((LevelObject, LightDesc::for_kind(AuthoringLightKind::Point)))
.id();
flush_level_object_hydration(app.world_mut());
assert!(app.world().get::<PointLight>(entity).is_some());
}
#[test]
fn flush_hydration_skips_inactive_light_desc() {
let mut app = App::new();
app.add_plugins(MinimalPlugins);
app.add_plugins(AssetPlugin::default());
app.add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default());
app.init_asset::<Mesh>();
let mut order = InspectorOrder::default();
order.set_component_active(COMPONENT_LIGHT_DESC, false);
let entity = app
.world_mut()
.spawn((
LevelObject,
LightDesc::for_kind(AuthoringLightKind::Point),
order,
))
.id();
flush_level_object_hydration(app.world_mut());
assert!(app.world().get::<PointLight>(entity).is_none());
}
#[test]
fn strip_hydrated_removes_runtime_mesh_and_lights() {
let mut app = App::new();
app.add_plugins(MinimalPlugins);
let entity = app
.world_mut()
.spawn((
Mesh3d::default(),
MeshMaterial3d::<StandardMaterial>::default(),
PointLight::default(),
RigidBody::Static,
Collider::sphere(1.0),
))
.id();
{
let mut entity_mut = app.world_mut().entity_mut(entity);
strip_hydrated_entity(&mut entity_mut);
}
let world = app.world();
assert!(world.get::<Mesh3d>(entity).is_none());
assert!(world.get::<PointLight>(entity).is_none());
assert!(world.get::<RigidBody>(entity).is_none());
}
#[test]
fn flush_hydration_spawns_mesh_material_from_primitive_and_desc() {
let mut app = App::new();
app.add_plugins(MinimalPlugins);
app.add_plugins(AssetPlugin::default());
app.add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default());
app.init_asset::<Mesh>();
let material = MaterialDesc::new(ColorDesc::srgb(0.85, 0.85, 0.88), 0.0, 0.3);
let entity = app
.world_mut()
.spawn((
LevelObject,
Primitive::cuboid(Vec3::new(1.2, 7.0, 1.2)),
material,
))
.id();
flush_level_object_hydration(app.world_mut());
assert!(app.world().get::<Mesh3d>(entity).is_some());
assert!(app
.world()
.get::<MeshMaterial3d<StandardMaterial>>(entity)
.is_some());
}
}
+36
View File
@@ -0,0 +1,36 @@
//! Imported model scenes from [`ModelRef`] authoring data.
use bevy::gltf::GltfAssetLabel;
use bevy::prelude::*;
use bevy::scene::SceneRoot;
use crate::{asset_server_path, LevelObject, ModelRef};
use super::strip::despawn_generated_children;
#[allow(clippy::type_complexity)]
pub fn hydrate_models(
mut commands: Commands,
asset_server: Res<AssetServer>,
models: Query<
(Entity, &ModelRef),
(With<LevelObject>, Or<(Added<ModelRef>, Changed<ModelRef>)>),
>,
children: Query<&Children>,
) {
for (entity, model) in &models {
if let Ok(child_list) = children.get(entity) {
despawn_generated_children(&mut commands, entity, child_list);
}
commands.entity(entity).remove::<SceneRoot>();
let path = asset_server_path(&model.path);
let handle = if path.ends_with(".fbx") {
asset_server.load(ModelRef::fbx_scene_asset_path(&path, model.scene_index))
} else {
asset_server.load(GltfAssetLabel::Scene(model.scene_index).from_asset(path))
};
commands.entity(entity).insert(SceneRoot(handle));
}
}
+97
View File
@@ -0,0 +1,97 @@
//! Avian physics from [`PhysicsBody`] authoring data.
use avian3d::prelude::*;
use bevy::prelude::*;
use crate::{
inspector_component_active, AuthoringRigidBody, ColliderDesc, ColliderShapeDesc,
InspectorOrder, LevelObject, PhysicsBody, RigidBodyDesc, COMPONENT_COLLIDER_DESC,
COMPONENT_PHYSICS_BODY, COMPONENT_RIGID_BODY_DESC,
};
#[allow(clippy::type_complexity)]
pub fn hydrate_physics(
mut commands: Commands,
physics: Query<
(Entity, &PhysicsBody, Option<&InspectorOrder>),
(
With<LevelObject>,
Or<(Changed<PhysicsBody>, Changed<InspectorOrder>)>,
),
>,
new_physics: Query<
(Entity, &PhysicsBody, Option<&InspectorOrder>),
(With<LevelObject>, Added<PhysicsBody>),
>,
split_physics: Query<
(
Entity,
Option<&RigidBodyDesc>,
Option<&ColliderDesc>,
Option<&InspectorOrder>,
),
(
With<LevelObject>,
Or<(
Changed<RigidBodyDesc>,
Added<RigidBodyDesc>,
Changed<ColliderDesc>,
Added<ColliderDesc>,
Changed<InspectorOrder>,
)>,
),
>,
) {
for (entity, body, order) in new_physics.iter().chain(physics.iter()) {
if !inspector_component_active(order, COMPONENT_PHYSICS_BODY) {
commands
.entity(entity)
.remove::<RigidBody>()
.remove::<Collider>();
continue;
}
let rigid_body = match body.body {
AuthoringRigidBody::Static => RigidBody::Static,
AuthoringRigidBody::Kinematic => RigidBody::Kinematic,
AuthoringRigidBody::Dynamic => RigidBody::Dynamic,
};
commands
.entity(entity)
.remove::<RigidBody>()
.remove::<Collider>()
.insert((rigid_body, body.collider.clone()));
}
for (entity, rigid_body, collider, order) in &split_physics {
let mut entity_commands = commands.entity(entity);
entity_commands.remove::<RigidBody>().remove::<Collider>();
if let Some(rigid_body) =
rigid_body.filter(|_| inspector_component_active(order, COMPONENT_RIGID_BODY_DESC))
{
entity_commands.insert(rigid_body_from_desc(rigid_body.body));
}
let Some(collider) = collider else {
continue;
};
if !inspector_component_active(order, COMPONENT_COLLIDER_DESC) {
continue;
}
if !collider.enabled || matches!(collider.shape, ColliderShapeDesc::StaticMesh { .. }) {
continue;
}
if let Some(constructor) = collider.shape.to_constructor() {
entity_commands.insert(constructor);
}
}
}
pub fn rigid_body_from_desc(body: AuthoringRigidBody) -> RigidBody {
match body {
AuthoringRigidBody::Static => RigidBody::Static,
AuthoringRigidBody::Kinematic => RigidBody::Kinematic,
AuthoringRigidBody::Dynamic => RigidBody::Dynamic,
}
}
+43
View File
@@ -0,0 +1,43 @@
//! Prefab scene roots from [`PrefabRef`] / [`PrefabInstance`] authoring data.
use bevy::prelude::*;
use bevy::scene::DynamicSceneRoot;
use crate::{LevelObject, PrefabInstance, PrefabRef};
use crate::asset_server_path;
#[allow(clippy::type_complexity)]
pub fn hydrate_prefabs(
mut commands: Commands,
asset_server: Res<AssetServer>,
prefabs: Query<
(Entity, &PrefabRef),
(
With<LevelObject>,
Without<PrefabInstance>,
Or<(Added<PrefabRef>, Changed<PrefabRef>)>,
),
>,
prefab_instances: Query<
(Entity, &PrefabInstance),
(
With<LevelObject>,
Or<(Added<PrefabInstance>, Changed<PrefabInstance>)>,
),
>,
) {
for (entity, prefab) in &prefabs {
commands.entity(entity).insert(DynamicSceneRoot(
asset_server.load(asset_server_path(&prefab.path)),
));
}
for (entity, instance) in &prefab_instances {
let path = asset_server_path(&instance.source_path);
commands.entity(entity).insert((
PrefabRef::new(instance.source_path.clone()),
DynamicSceneRoot(asset_server.load(path)),
));
}
}
+84
View File
@@ -0,0 +1,84 @@
//! Mesh geometry from [`Primitive`] authoring data.
use bevy::prelude::*;
use crate::{
inspector_component_active, InspectorOrder, LevelObject, Primitive, PrimitiveShape,
COMPONENT_PRIMITIVE,
};
pub(crate) fn primitive_mesh(primitive: &Primitive) -> Mesh {
let mut mesh = match primitive.shape {
PrimitiveShape::Box => Cuboid::new(primitive.size.x, primitive.size.y, primitive.size.z)
.mesh()
.build(),
PrimitiveShape::Sphere => {
let radius = primitive.size.max_element() * 0.5;
Sphere::new(radius).mesh().uv(48, 24)
}
PrimitiveShape::Ramp => Cuboid::new(primitive.size.x, primitive.size.y, primitive.size.z)
.mesh()
.build(),
};
if let Err(error) = mesh.generate_tangents() {
warn!("Primitive mesh is not Solari-compatible: failed to generate tangents: {error:?}");
}
mesh
}
#[allow(clippy::type_complexity)]
pub fn hydrate_primitives(
mut commands: Commands,
primitives: Query<
(Entity, &Primitive, Option<&InspectorOrder>),
(
With<LevelObject>,
Or<(
Added<Primitive>,
Changed<Primitive>,
Changed<InspectorOrder>,
)>,
),
>,
mut meshes: ResMut<Assets<Mesh>>,
) {
for (entity, primitive, order) in &primitives {
if !inspector_component_active(order, COMPONENT_PRIMITIVE) {
commands
.entity(entity)
.remove::<Mesh3d>()
.remove::<MeshMaterial3d<StandardMaterial>>();
continue;
}
let mesh = meshes.add(primitive_mesh(primitive));
commands.entity(entity).insert(Mesh3d(mesh));
}
}
#[cfg(test)]
mod tests {
use super::*;
use bevy::mesh::{Indices, PrimitiveTopology};
#[test]
fn primitive_meshes_are_solari_compatible() {
for primitive in [
Primitive::cuboid(Vec3::ONE),
Primitive::sphere(1.0),
Primitive::ramp(Vec3::ONE),
] {
let mesh = primitive_mesh(&primitive);
assert_eq!(mesh.primitive_topology(), PrimitiveTopology::TriangleList);
assert!(mesh.attribute(Mesh::ATTRIBUTE_POSITION).is_some());
assert!(mesh.attribute(Mesh::ATTRIBUTE_NORMAL).is_some());
assert!(mesh.attribute(Mesh::ATTRIBUTE_UV_0).is_some());
assert!(mesh.attribute(Mesh::ATTRIBUTE_TANGENT).is_some());
assert!(matches!(mesh.indices(), Some(Indices::U32(_))));
assert!(mesh.enable_raytracing);
}
}
}
@@ -0,0 +1,378 @@
//! Static mesh renderer hydration from normalized authoring entries.
use avian3d::prelude::ColliderConstructor;
use bevy::light::{NotShadowCaster, NotShadowReceiver};
use bevy::prelude::*;
use serde::Deserialize;
use std::collections::{HashMap, HashSet};
use crate::{
asset_server_path, inspector_component_active, ColliderDesc, ColliderShapeDesc, EditorAssetRef,
InspectorOrder, LevelObject, MaterialDesc, MaterialOverride, StaticMeshRenderer,
StaticMeshRendererEntry, COMPONENT_COLLIDER_DESC, COMPONENT_MATERIAL_DESC,
COMPONENT_STATIC_MESH_RENDERER,
};
use super::materials::material_from_desc;
pub const STATIC_MESH_ARTIFACT_DIR: &str = "assets/meshes/generated";
/// Runtime marker for mesh children generated from [`StaticMeshRenderer`].
#[derive(Component, Reflect, Default, Debug, Clone, Copy)]
#[reflect(Component, Default, Debug)]
pub struct HydratedStaticMeshPart;
#[derive(Debug, Clone)]
struct ResolvedStaticMeshPart {
source_path: String,
mesh_label: String,
material_label: Option<String>,
}
#[derive(Debug, Clone)]
struct ResolvedStaticMeshMaterial {
source_path: String,
material_label: String,
}
/// Cache for generated static mesh artifact lookups.
#[derive(Resource, Default)]
pub struct StaticMeshArtifactCache {
parts: HashMap<(String, String), ResolvedStaticMeshPart>,
materials: HashMap<(String, String), ResolvedStaticMeshMaterial>,
loaded_assets: HashSet<String>,
failed_assets: HashSet<String>,
}
impl StaticMeshArtifactCache {
fn resolve(&mut self, mesh: &EditorAssetRef) -> Option<ResolvedStaticMeshPart> {
if !mesh.is_resolved() {
return None;
}
let key = (mesh.asset_id.clone(), mesh.sub_asset_id.clone());
if let Some(part) = self.parts.get(&key) {
return Some(part.clone());
}
if !self.loaded_assets.contains(&mesh.asset_id)
&& !self.failed_assets.contains(&mesh.asset_id)
{
self.load_artifact(&mesh.asset_id);
}
self.parts.get(&key).cloned()
}
fn resolve_material(
&mut self,
material: &EditorAssetRef,
) -> Option<ResolvedStaticMeshMaterial> {
if !material.is_resolved() {
return None;
}
let key = (material.asset_id.clone(), material.sub_asset_id.clone());
if let Some(material) = self.materials.get(&key) {
return Some(material.clone());
}
if !self.loaded_assets.contains(&material.asset_id)
&& !self.failed_assets.contains(&material.asset_id)
{
self.load_artifact(&material.asset_id);
}
self.materials.get(&key).cloned()
}
fn load_artifact(&mut self, asset_id: &str) {
let path = static_mesh_manifest_path(asset_id);
match std::fs::read_to_string(&path)
.map_err(|err| format!("could not read {path}: {err}"))
.and_then(|text| {
ron::from_str::<StaticMeshResolveManifest>(&text)
.map_err(|err| format!("could not parse {path}: {err}"))
}) {
Ok(manifest) => {
for part in manifest.parts {
let part_id = if part.id.trim().is_empty() {
part_id_from_label(&part.mesh_label)
} else {
part.id.clone()
};
self.parts.insert(
(asset_id.to_string(), part_id),
ResolvedStaticMeshPart {
source_path: manifest.source.path.clone(),
mesh_label: part.mesh_label.clone(),
material_label: part.material_label.clone(),
},
);
if let Some(material_label) = part.material_label {
let material_id = part
.material_id
.filter(|id| !id.trim().is_empty())
.unwrap_or_else(|| material_id_from_label(&material_label));
self.materials
.entry((asset_id.to_string(), material_id))
.or_insert(ResolvedStaticMeshMaterial {
source_path: manifest.source.path.clone(),
material_label,
});
}
}
self.loaded_assets.insert(asset_id.to_string());
}
Err(error) => {
warn!("Static mesh artifact lookup failed for asset {asset_id}: {error}");
self.failed_assets.insert(asset_id.to_string());
}
}
}
}
#[derive(Debug, Deserialize)]
struct StaticMeshResolveManifest {
source: StaticMeshResolveSource,
#[serde(default)]
parts: Vec<StaticMeshResolvePart>,
}
#[derive(Debug, Deserialize)]
struct StaticMeshResolveSource {
path: String,
}
#[derive(Debug, Deserialize)]
struct StaticMeshResolvePart {
#[serde(default)]
id: String,
mesh_label: String,
#[serde(default)]
material_id: Option<String>,
#[serde(default)]
material_label: Option<String>,
}
#[allow(clippy::type_complexity)]
pub fn hydrate_static_mesh_renderers(
mut commands: Commands,
asset_server: Res<AssetServer>,
mut materials: ResMut<Assets<StandardMaterial>>,
mut artifact_cache: ResMut<StaticMeshArtifactCache>,
renderers: Query<
(
Entity,
&StaticMeshRenderer,
Option<&MaterialDesc>,
Option<&MaterialOverride>,
Option<&ColliderDesc>,
Option<&InspectorOrder>,
),
(
With<LevelObject>,
Or<(
Added<StaticMeshRenderer>,
Changed<StaticMeshRenderer>,
Changed<MaterialDesc>,
Changed<MaterialOverride>,
Changed<ColliderDesc>,
Changed<InspectorOrder>,
)>,
),
>,
children: Query<&Children>,
generated_parts: Query<(), With<HydratedStaticMeshPart>>,
) {
for (entity, renderer, parent_material, material_override, collider, order) in &renderers {
despawn_static_mesh_parts(&mut commands, entity, &children, &generated_parts);
if !inspector_component_active(order, COMPONENT_STATIC_MESH_RENDERER) {
continue;
}
let parent_material =
parent_material.filter(|_| inspector_component_active(order, COMPONENT_MATERIAL_DESC));
let collider =
collider.filter(|_| inspector_component_active(order, COMPONENT_COLLIDER_DESC));
spawn_static_mesh_parts(
&mut commands,
&asset_server,
&mut materials,
&mut artifact_cache,
entity,
renderer,
parent_material,
material_override,
collider,
);
}
}
pub fn spawn_static_mesh_parts(
commands: &mut Commands,
asset_server: &AssetServer,
materials: &mut Assets<StandardMaterial>,
artifact_cache: &mut StaticMeshArtifactCache,
parent: Entity,
renderer: &StaticMeshRenderer,
parent_material: Option<&MaterialDesc>,
material_override: Option<&MaterialOverride>,
collider: Option<&ColliderDesc>,
) {
let mut spawned = 0usize;
for (index, entry) in renderer.slots.iter().enumerate() {
if !entry.visible {
continue;
}
let Some(resolved) = artifact_cache.resolve(&entry.mesh) else {
warn!(
"Static mesh renderer slot skipped: unresolved mesh asset ref asset_id='{}' part='{}' label='{}'",
entry.mesh.asset_id, entry.mesh.sub_asset_id, entry.mesh.label
);
continue;
};
let source_path = asset_server_path(&resolved.source_path);
let mesh_handle: Handle<Mesh> =
asset_server.load(labeled_asset_path(&source_path, &resolved.mesh_label));
let material_handle = material_for_entry(
asset_server,
materials,
artifact_cache,
entry,
&resolved,
parent_material,
material_override,
);
let name = if entry.name.trim().is_empty() {
format!("Static Mesh Part {index}")
} else {
entry.name.clone()
};
let mut part = commands.spawn((
HydratedStaticMeshPart,
Name::new(name),
Mesh3d(mesh_handle),
MeshMaterial3d(material_handle),
entry.local_transform,
Visibility::Visible,
ChildOf(parent),
));
if !entry.cast_shadows {
part.insert(NotShadowCaster);
}
if !entry.receive_shadows {
part.insert(NotShadowReceiver);
}
if should_attach_static_mesh_collider(collider, &entry.mesh) {
part.insert(ColliderConstructor::TrimeshFromMesh);
}
spawned += 1;
}
debug!(
"Hydrated static mesh renderer: parent={parent:?} slots={} spawned={spawned}",
renderer.slots.len()
);
}
pub fn despawn_static_mesh_parts(
commands: &mut Commands,
entity: Entity,
children: &Query<&Children>,
generated_parts: &Query<(), With<HydratedStaticMeshPart>>,
) {
let Ok(child_list) = children.get(entity) else {
return;
};
for child in child_list.iter() {
if generated_parts.get(child).is_ok() {
commands.entity(child).despawn();
}
}
}
fn material_for_entry(
asset_server: &AssetServer,
materials: &mut Assets<StandardMaterial>,
artifact_cache: &mut StaticMeshArtifactCache,
entry: &StaticMeshRendererEntry,
resolved: &ResolvedStaticMeshPart,
parent_material: Option<&MaterialDesc>,
material_override: Option<&MaterialOverride>,
) -> Handle<StandardMaterial> {
if let Some(override_material) = material_override.and_then(|overrides| {
overrides
.slots
.iter()
.find(|slot| slot.slot_id == entry.id)
.map(|slot| &slot.material)
}) {
return materials.add(material_from_desc(asset_server, override_material));
}
if let Some(material_ref) = entry.material.as_ref() {
if let Some(resolved_material) = artifact_cache.resolve_material(material_ref) {
let source_path = asset_server_path(&resolved_material.source_path);
return asset_server.load(labeled_asset_path(
&source_path,
&resolved_material.material_label,
));
}
debug!(
"Static mesh material ref unresolved: asset_id='{}' material='{}' label='{}'",
material_ref.asset_id, material_ref.sub_asset_id, material_ref.label
);
}
if let Some(label) = resolved.material_label.as_deref() {
let source_path = asset_server_path(&resolved.source_path);
return asset_server.load(labeled_asset_path(&source_path, label));
}
if let Some(parent_material) = parent_material {
return materials.add(material_from_desc(asset_server, parent_material));
}
materials.add(StandardMaterial::default())
}
fn labeled_asset_path(path: &str, label: &str) -> String {
format!("{path}#{label}")
}
fn should_attach_static_mesh_collider(
collider: Option<&ColliderDesc>,
mesh: &EditorAssetRef,
) -> bool {
let Some(collider) = collider else {
return false;
};
if !collider.enabled {
return false;
}
let ColliderShapeDesc::StaticMesh { meshes, .. } = &collider.shape else {
return false;
};
meshes.iter().any(|candidate| candidate == mesh)
}
pub fn static_mesh_manifest_path(asset_id: &str) -> String {
format!("{STATIC_MESH_ARTIFACT_DIR}/{asset_id}.static_mesh.ron")
}
fn part_id_from_label(label: &str) -> String {
format!("mesh:{}", stable_sub_asset_slug(label))
}
fn material_id_from_label(label: &str) -> String {
format!("material:{}", stable_sub_asset_slug(label))
}
fn stable_sub_asset_slug(label: &str) -> String {
let mut slug = String::new();
for ch in label.chars() {
if ch.is_ascii_alphanumeric() {
slug.push(ch.to_ascii_lowercase());
} else if !slug.ends_with('_') {
slug.push('_');
}
}
slug.trim_matches('_').to_string()
}
+41
View File
@@ -0,0 +1,41 @@
//! Removes runtime-only components generated by hydration before save or re-hydrate.
use avian3d::prelude::*;
use bevy::prelude::*;
use bevy::scene::{DynamicSceneRoot, SceneRoot};
/// Strips hydrated components via [`EntityWorldMut`] (e.g. before scene save).
pub fn strip_hydrated_entity(entity: &mut EntityWorldMut<'_>) {
entity
.remove::<Mesh3d>()
.remove::<MeshMaterial3d<StandardMaterial>>()
.remove::<PointLight>()
.remove::<SpotLight>()
.remove::<DirectionalLight>()
.remove::<SceneRoot>()
.remove::<DynamicSceneRoot>()
.remove::<RigidBody>()
.remove::<Collider>();
}
/// Strips all components hydration may insert so authoring data can be re-applied cleanly.
pub fn strip_hydrated(entity_commands: &mut EntityCommands<'_>) {
entity_commands
.remove::<Mesh3d>()
.remove::<MeshMaterial3d<StandardMaterial>>()
.remove::<PointLight>()
.remove::<SpotLight>()
.remove::<DirectionalLight>()
.remove::<SceneRoot>()
.remove::<DynamicSceneRoot>()
.remove::<RigidBody>()
.remove::<Collider>();
}
/// Despawns all child entities (e.g. prior `SceneRoot` instance hierarchy).
pub fn despawn_generated_children(commands: &mut Commands, entity: Entity, children: &Children) {
for child in children.iter() {
commands.entity(child).despawn();
}
commands.entity(entity).remove::<Children>();
}
+41
View File
@@ -0,0 +1,41 @@
//! Maps authoring [`EditorVisibility`] to runtime [`Visibility`].
use crate::{EditorVisibility, LevelObject};
use bevy::prelude::*;
pub fn sync_editor_visibility(
mut query: Query<
(&EditorVisibility, &mut Visibility),
(
With<LevelObject>,
Or<(Changed<EditorVisibility>, Added<EditorVisibility>)>,
),
>,
) {
for (editor, mut visibility) in query.iter_mut() {
*visibility = if editor.visible {
Visibility::Visible
} else {
Visibility::Hidden
};
}
}
pub fn init_editor_visibility_on_spawn(
mut query: Query<
(&EditorVisibility, &mut Visibility),
(
With<LevelObject>,
Added<LevelObject>,
With<EditorVisibility>,
),
>,
) {
for (editor, mut visibility) in query.iter_mut() {
*visibility = if editor.visible {
Visibility::Visible
} else {
Visibility::Hidden
};
}
}
+90
View File
@@ -0,0 +1,90 @@
//! Shared editor/game authoring data and hydration.
//!
//! Saved levels are Bevy dynamic scenes made from these small, reflectable
//! authoring components. Runtime-only render/physics components are generated
//! from them by hydration systems in both the game and editor.
mod actor;
mod components;
mod hydration;
mod material_asset;
mod post_process_effect_asset;
mod rendering_profile_asset;
pub use actor::{infer_actor_kind, validate_actor, ActorValidationError};
pub use components::*;
pub use hydration::{
cascade_config_from_rendering, flush_level_object_hydration, strip_hydrated,
strip_hydrated_entity, HydrationPlugin,
};
pub use material_asset::{
MaterialAsset, ShaderPropertyDesc, ShaderPropertyType, ShaderSchemaAsset,
};
pub use post_process_effect_asset::{PostProcessEffectAsset, PostProcessEffectKind};
pub use rendering_profile_asset::RenderingProfileAsset;
/// Converts catalog-style paths (`assets/models/foo.fbx`) to Bevy AssetServer paths.
pub fn asset_server_path(catalog_path: &str) -> String {
let normalized = catalog_path.replace('\\', "/");
normalized
.strip_prefix("assets/")
.map(str::to_string)
.unwrap_or(normalized)
}
use bevy::prelude::*;
/// Registers all reflectable authoring types and installs hydration systems.
pub struct SharedTypesPlugin;
impl Plugin for SharedTypesPlugin {
fn build(&self, app: &mut App) {
app.register_type::<ActorKind>()
.register_type::<ActorId>()
.register_type::<ActorName>()
.register_type::<HierarchySiblingIndex>()
.register_type::<InspectorOrder>()
.register_type::<InspectorComponentState>()
.register_type::<ComponentInstanceId>()
.register_type::<EditorAssetRef>()
.register_type::<EditorVisibility>()
.register_type::<LevelObject>()
.register_type::<RaytracingExcluded>()
.register_type::<PlayerSpawn>()
.register_type::<ProjectSun>()
.register_type::<Primitive>()
.register_type::<PrimitiveShape>()
.register_type::<StaticMeshRenderer>()
.register_type::<StaticMeshRendererEntry>()
.register_type::<StaticMeshAssetRef>()
.register_type::<StaticMeshMaterialSlot>()
.register_type::<StaticMeshColliderMode>()
.register_type::<MaterialDesc>()
.register_type::<MaterialShaderKind>()
.register_type::<ShaderRefDesc>()
.register_type::<MaterialParameterValue>()
.register_type::<MaterialParameter>()
.register_type::<MaterialTextureBinding>()
.register_type::<MaterialSlotOverride>()
.register_type::<MaterialOverride>()
.register_type::<ColorDesc>()
.register_type::<LightDesc>()
.register_type::<AuthoringLightKind>()
.register_type::<RigidBodyDesc>()
.register_type::<ColliderDesc>()
.register_type::<ColliderShapeDesc>()
.register_type::<MeshColliderCooking>()
.register_type::<PhysicsBody>()
.register_type::<AuthoringRigidBody>()
.register_type::<ModelRef>()
.register_type::<PrefabRef>()
.register_type::<PrefabInstance>()
.register_type::<WeaponSpawn>()
.register_type::<TriggerVolume>()
.register_type::<PostProcessVolumeDesc>()
.register_type::<PostProcessVolumeOverrides>()
.register_type::<TeamSpawn>()
.register_type::<ObjectiveMarker>()
.add_plugins(HydrationPlugin);
}
}
+66
View File
@@ -0,0 +1,66 @@
//! Serializable material asset files under `assets/materials/`.
use serde::{Deserialize, Serialize};
use crate::{MaterialDesc, MaterialParameter, MaterialShaderKind, MaterialTextureBinding};
/// RON material asset: label plus authoring [`MaterialDesc`].
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MaterialAsset {
pub label: String,
#[serde(default)]
pub shader: Option<String>,
pub material: MaterialDesc,
}
impl MaterialAsset {
pub fn load_from_path(catalog_path: &str) -> Result<Self, String> {
let text = std::fs::read_to_string(catalog_path)
.map_err(|err| format!("could not read {catalog_path}: {err}"))?;
ron::from_str(&text).map_err(|err| format!("invalid material RON in {catalog_path}: {err}"))
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ShaderPropertyType {
Bool,
Float { min: Option<f32>, max: Option<f32> },
Vec2,
Vec3,
Color,
Enum { options: Vec<String> },
Texture,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ShaderPropertyDesc {
pub name: String,
pub display_name: String,
#[serde(default)]
pub group: String,
pub property_type: ShaderPropertyType,
}
/// RON shader schema describing material inspector parameters.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ShaderSchemaAsset {
pub label: String,
pub kind: MaterialShaderKind,
#[serde(default)]
pub wgsl_path: Option<String>,
#[serde(default)]
pub parameters: Vec<ShaderPropertyDesc>,
#[serde(default)]
pub default_values: Vec<MaterialParameter>,
#[serde(default)]
pub default_textures: Vec<MaterialTextureBinding>,
}
impl ShaderSchemaAsset {
pub fn load_from_path(catalog_path: &str) -> Result<Self, String> {
let text = std::fs::read_to_string(catalog_path)
.map_err(|err| format!("could not read {catalog_path}: {err}"))?;
ron::from_str(&text)
.map_err(|err| format!("invalid shader schema RON in {catalog_path}: {err}"))
}
}
@@ -0,0 +1,30 @@
//! Fullscreen post-process effect assets under `assets/post_fx/`.
use serde::{Deserialize, Serialize};
/// Built-in effect kinds shipped with sample WGSL shaders.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum PostProcessEffectKind {
#[default]
Vignette,
ChromaticAberration,
}
/// RON asset describing a fullscreen post effect.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PostProcessEffectAsset {
pub label: String,
pub kind: PostProcessEffectKind,
/// WGSL path relative to `assets/`.
pub shader: String,
pub intensity: f32,
pub radius: f32,
}
impl PostProcessEffectAsset {
pub fn load_from_path(catalog_path: &str) -> Result<Self, String> {
let text = std::fs::read_to_string(catalog_path)
.map_err(|err| format!("could not read {catalog_path}: {err}"))?;
ron::from_str(&text).map_err(|err| format!("invalid post FX RON in {catalog_path}: {err}"))
}
}
@@ -0,0 +1,21 @@
//! Named rendering override bundles under `assets/rendering_profiles/`.
use serde::{Deserialize, Serialize};
use crate::PostProcessVolumeOverrides;
/// RON preset: label plus override bundle applied to volumes or project drafts.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenderingProfileAsset {
pub label: String,
pub overrides: PostProcessVolumeOverrides,
}
impl RenderingProfileAsset {
pub fn load_from_path(catalog_path: &str) -> Result<Self, String> {
let text = std::fs::read_to_string(catalog_path)
.map_err(|err| format!("could not read {catalog_path}: {err}"))?;
ron::from_str(&text)
.map_err(|err| format!("invalid rendering profile RON in {catalog_path}: {err}"))
}
}