This commit is contained in:
commit
f29712d158
259 files changed
+52069
No files matched your search
@@ -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
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
@@ -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)),
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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>();
|
||||
}
|
||||
@@ -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
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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}"))
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user