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

+306
View File
@@ -0,0 +1,306 @@
//! Editor-only Project Settings panel (egui). Data lives in the `settings` crate.
use bevy::prelude::*;
use bevy_egui::egui;
use game_hot::sync_project_sun_from_settings;
use settings::{
load_project_settings_from_path, save_project_settings, sync_sim_tuning, ExposureMode,
ProjectSettings, ProjectSettingsChanged, ProjectSettingsIo,
};
/// Whether the Project Settings window is visible (editor UI state only).
#[derive(Resource, Debug, Default)]
pub struct ProjectSettingsPanel {
pub open: bool,
pub draft: Option<ProjectSettings>,
}
pub struct SettingsUiPlugin;
impl Plugin for SettingsUiPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<ProjectSettingsPanel>().add_systems(
PostUpdate,
apply_project_settings_changes
.after(crate::scene_view::sync_editor_camera_viewport_target),
);
}
}
pub fn open_project_settings_panel(panel: &mut ProjectSettingsPanel) {
panel.open = true;
panel.draft = None;
}
pub fn project_settings_window(
world: &mut World,
ctx: &egui::Context,
panel: &mut ProjectSettingsPanel,
) {
if !panel.open {
panel.draft = None;
return;
}
if panel.draft.is_none() {
panel.draft = Some(world.resource::<ProjectSettings>().clone());
}
let mut open = panel.open;
egui::Window::new("Project Settings")
.open(&mut open)
.default_width(420.0)
.show(ctx, |ui| {
let Some(draft) = panel.draft.as_mut() else {
return;
};
let io_path = world.resource::<ProjectSettingsIo>().path.clone();
let mut io_dirty = world.resource::<ProjectSettingsIo>().dirty;
draw_project_settings_form(world, ui, draft, &io_path, &mut io_dirty);
world.resource_mut::<ProjectSettingsIo>().dirty = io_dirty;
});
panel.open = open;
if !open {
panel.draft = None;
}
}
fn draw_project_settings_form(
world: &mut World,
ui: &mut egui::Ui,
draft: &mut ProjectSettings,
io_path: &str,
io_dirty: &mut bool,
) {
let caps = world
.get_resource::<settings::RenderingCapabilities>()
.cloned()
.unwrap_or_default();
ui.collapsing("Global Illumination", |ui| {
egui::ComboBox::from_label("GiMode")
.selected_text(format!("{:?}", draft.rendering.gi_mode))
.show_ui(ui, |ui| {
for mode in [
settings::GiMode::Auto,
settings::GiMode::Forward,
settings::GiMode::Solari,
] {
if ui
.selectable_value(&mut draft.rendering.gi_mode, mode, format!("{mode:?}"))
.clicked()
{}
}
});
ui.small("Auto uses Solari when RT GPU support is available; otherwise Forward PBR.");
let status = match (draft.rendering.gi_mode, caps.rt_supported) {
(settings::GiMode::Forward, _) => "Forward PBR",
(settings::GiMode::Solari, true) => "Solari active",
(settings::GiMode::Solari, false) => "Solari requested — will fall back (no RT)",
(settings::GiMode::Auto, true) => "Auto → Solari when playing",
(settings::GiMode::Auto, false) => "Auto → Forward fallback (no RT)",
};
ui.label(format!("Status: {status}"));
ui.small("Open Window → Rendering for resolved active-camera stack.");
});
ui.collapsing("Lighting", |ui| {
ui.label("Ambient");
ui.horizontal(|ui| {
let mut rgb = [
draft.rendering.ambient_color[0],
draft.rendering.ambient_color[1],
draft.rendering.ambient_color[2],
];
if ui.color_edit_button_rgb(&mut rgb).changed() {
draft.rendering.ambient_color = rgb;
}
});
ui.add(
egui::Slider::new(&mut draft.rendering.ambient_brightness, 0.0..=200.0)
.text("Ambient brightness"),
);
ui.add(
egui::Slider::new(&mut draft.rendering.sun_illuminance, 1_000.0..=150_000.0)
.text("Sun illuminance (lux)"),
);
ui.add(
egui::Slider::new(&mut draft.rendering.shadow_cascades, 1..=4).text("Shadow cascades"),
);
ui.add(
egui::Slider::new(&mut draft.rendering.shadow_first_cascade, 1.0..=20.0)
.text("First cascade (m)"),
);
ui.add(
egui::Slider::new(&mut draft.rendering.shadow_max_distance, 50.0..=500.0)
.text("Shadow max distance"),
);
});
ui.collapsing("Post Process", |ui| {
ui.checkbox(&mut draft.rendering.hdr, "HDR");
ui.small("The viewport uses HDR when Lit mode is active.");
ui.horizontal(|ui| {
ui.label("Exposure");
if ui
.selectable_label(
draft.rendering.exposure_mode == ExposureMode::Manual,
"Manual",
)
.clicked()
{
draft.rendering.exposure_mode = ExposureMode::Manual;
}
if ui
.selectable_label(draft.rendering.exposure_mode == ExposureMode::Auto, "Auto")
.clicked()
{
draft.rendering.exposure_mode = ExposureMode::Auto;
}
});
let manual = draft.rendering.exposure_mode == ExposureMode::Manual;
if manual {
ui.add(
egui::Slider::new(&mut draft.rendering.exposure_ev100, 0.0..=20.0)
.text("Exposure EV100"),
);
} else {
ui.add_enabled(
false,
egui::Slider::new(&mut draft.rendering.exposure_ev100, 0.0..=20.0)
.text("Exposure EV100"),
);
ui.small("Scene brightness adapts automatically (histogram metering).");
ui.add(
egui::Slider::new(
&mut draft.rendering.auto_exposure_speed_brighten,
0.1..=10.0,
)
.text("Auto brighten (f-stops/s)"),
);
ui.add(
egui::Slider::new(&mut draft.rendering.auto_exposure_speed_darken, 0.1..=10.0)
.text("Auto darken (f-stops/s)"),
);
if !draft.rendering.hdr {
ui.colored_label(
egui::Color32::from_rgb(255, 180, 100),
"Auto exposure requires HDR — enable HDR or use Manual.",
);
} else {
ui.small("Requires GPU compute; see Window → Rendering if unavailable.");
}
}
ui.checkbox(&mut draft.rendering.tonemapping_aces, "Tonemapping ACES");
ui.checkbox(&mut draft.rendering.bloom, "Bloom");
ui.checkbox(&mut draft.rendering.taa, "TAA");
ui.checkbox(&mut draft.rendering.ssao, "SSAO");
ui.checkbox(&mut draft.rendering.atmosphere, "Atmosphere");
ui.label("Fog");
ui.horizontal(|ui| {
let mut fog_rgb = draft.rendering.fog_color;
if ui.color_edit_button_rgb(&mut fog_rgb).changed() {
draft.rendering.fog_color = fog_rgb;
}
});
ui.add(
egui::Slider::new(&mut draft.rendering.fog_density, 0.0..=0.01)
.logarithmic(true)
.text("Fog density"),
);
});
ui.separator();
ui.heading("Physics");
ui.add(egui::Slider::new(&mut draft.physics.walk_speed, 1.0..=15.0).text("Walk speed"));
ui.add(egui::Slider::new(&mut draft.physics.run_speed, 1.0..=20.0).text("Run speed"));
ui.add(egui::Slider::new(&mut draft.physics.gravity, 5.0..=40.0).text("Gravity"));
ui.add(egui::Slider::new(&mut draft.physics.jump_speed, 3.0..=15.0).text("Jump speed"));
ui.separator();
ui.heading("Input");
ui.add(
egui::Slider::new(&mut draft.input.yaw_sensitivity, 0.0005..=0.01).text("Yaw sensitivity"),
);
ui.add(
egui::Slider::new(&mut draft.input.pitch_sensitivity, 0.0005..=0.01)
.text("Pitch sensitivity"),
);
ui.add(
egui::Slider::new(&mut draft.input.editor_fly_speed, 2.0..=40.0).text("Editor fly speed"),
);
ui.separator();
if ui.button("Apply").clicked() {
commit_project_settings(world, draft);
*io_dirty = true;
}
if ui.button("Save to disk").clicked() {
commit_project_settings(world, draft);
let settings = world.resource::<ProjectSettings>().clone();
let mut io = world.resource_mut::<ProjectSettingsIo>();
if let Err(error) = save_project_settings(&settings, &mut io) {
warn!("Save project settings failed: {error}");
} else {
*io_dirty = false;
}
}
if ui.button("Revert from disk").clicked() {
*draft = load_project_settings_from_path(io_path);
commit_project_settings(world, draft);
world.resource_mut::<ProjectSettingsIo>().dirty = false;
*io_dirty = false;
}
if *io_dirty {
ui.label(egui::RichText::new("Unsaved changes").color(egui::Color32::YELLOW));
}
}
fn commit_project_settings(world: &mut World, draft: &ProjectSettings) {
let previous = world.resource::<ProjectSettings>().rendering.gi_mode;
*world.resource_mut::<ProjectSettings>() = draft.clone();
if previous != draft.rendering.gi_mode {
info!(
"Project settings GI mode changed: {:?} -> {:?}",
previous, draft.rendering.gi_mode
);
} else {
debug!(
"Project settings applied: gi_mode={:?}",
draft.rendering.gi_mode
);
}
world.write_message(ProjectSettingsChanged);
}
fn apply_project_settings_changes(
mut reader: MessageReader<ProjectSettingsChanged>,
mut commands: Commands,
settings: Res<ProjectSettings>,
tuning: ResMut<settings::SimTuning>,
scene_suns: Query<
(&shared::LightDesc, Option<&shared::InspectorOrder>),
With<shared::LevelObject>,
>,
project_suns: Query<(&mut DirectionalLight, &mut Visibility), With<shared::ProjectSun>>,
) {
if reader.read().next().is_none() {
return;
}
sync_sim_tuning(&settings, tuning);
{
let ambient = settings.rendering.clone();
commands.insert_resource(GlobalAmbientLight {
color: Color::srgb(
ambient.ambient_color[0],
ambient.ambient_color[1],
ambient.ambient_color[2],
),
brightness: ambient.ambient_brightness,
..default()
});
}
sync_project_sun_from_settings(settings, scene_suns, project_suns);
// Full stack refresh runs next frame via `render_view::sync_project_render_view`
// when `ProjectSettings` changes.
}