This commit is contained in:
1 parent
293811aecd
commit
d1a56f77cc
23 files changed
+1730
-62
No files matched your search
@@ -1415,16 +1415,13 @@ pub fn apply_reflected_component(
|
||||
let reflected = TypedReflectDeserializer::new(registration, &type_registry)
|
||||
.deserialize(&mut deserializer)
|
||||
.map_err(|error| error.to_string())?;
|
||||
let exists = reflect_component.reflect(world.entity(entity)).is_some();
|
||||
if exists {
|
||||
reflect_component.apply(world.entity_mut(entity), reflected.as_ref());
|
||||
} else {
|
||||
reflect_component.insert(
|
||||
&mut world.entity_mut(entity),
|
||||
reflected.as_ref(),
|
||||
&type_registry,
|
||||
);
|
||||
}
|
||||
// Reflected `apply` merges list fields and cannot restore a shorter snapshot.
|
||||
// Inserting the captured concrete component replaces the value atomically.
|
||||
reflect_component.insert(
|
||||
&mut world.entity_mut(entity),
|
||||
reflected.as_ref(),
|
||||
&type_registry,
|
||||
);
|
||||
}
|
||||
None => reflect_component.remove(&mut world.entity_mut(entity)),
|
||||
}
|
||||
@@ -1451,16 +1448,11 @@ pub fn apply_reflected_default(
|
||||
.data::<ReflectDefault>()
|
||||
.ok_or_else(|| format!("component `{type_path}` has no reflected Default"))?
|
||||
.default();
|
||||
let exists = reflect_component.reflect(world.entity(entity)).is_some();
|
||||
if exists {
|
||||
reflect_component.apply(world.entity_mut(entity), default.as_ref());
|
||||
} else {
|
||||
reflect_component.insert(
|
||||
&mut world.entity_mut(entity),
|
||||
default.as_ref(),
|
||||
&type_registry,
|
||||
);
|
||||
}
|
||||
reflect_component.insert(
|
||||
&mut world.entity_mut(entity),
|
||||
default.as_ref(),
|
||||
&type_registry,
|
||||
);
|
||||
Ok(())
|
||||
})
|
||||
}
|
||||
|
||||
@@ -43,6 +43,7 @@ pub use viewport::render_view;
|
||||
pub use viewport::rendering_diagnostics;
|
||||
pub use viewport::selection;
|
||||
pub use viewport::selection_outline;
|
||||
pub use viewport::terrain_paint;
|
||||
pub use viewport::terrain_sculpt;
|
||||
pub use viewport::visualizers;
|
||||
|
||||
@@ -80,6 +81,7 @@ use selection_outline::SelectionOutlinePlugin;
|
||||
use session::EditorSessionPlugin;
|
||||
use settings_ui::SettingsUiPlugin;
|
||||
use state::EditorStatePlugin;
|
||||
use terrain_paint::TerrainPaintPlugin;
|
||||
use terrain_sculpt::TerrainSculptPlugin;
|
||||
use ui::EditorUiPlugin;
|
||||
use viewport::ViewportPlugin;
|
||||
@@ -112,6 +114,7 @@ impl PluginGroup for EditorPluginGroup {
|
||||
.add(BrushEditPlugin)
|
||||
.add(BrushToolPlugin)
|
||||
.add(TerrainSculptPlugin)
|
||||
.add(TerrainPaintPlugin)
|
||||
.add(EditorCameraPlugin)
|
||||
.add(AudioPreviewPlugin)
|
||||
.add(ActorIconsPlugin)
|
||||
|
||||
@@ -3496,12 +3496,23 @@ fn brush_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||||
}
|
||||
|
||||
fn terrain_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||||
let material_candidates = brush_face_material_ref_candidates(world);
|
||||
let dragging_selection = world
|
||||
.get_resource::<EditorAssets>()
|
||||
.and_then(|assets| assets.dragging_selection().cloned());
|
||||
let material_drop_candidate = dragging_selection.as_ref().and_then(|selection| {
|
||||
asset_ref_candidate_from_selection(world, selection, AssetRefCandidateKind::Material)
|
||||
});
|
||||
let Some(mut terrain) = world.get::<TerrainDesc>(entity).cloned() else {
|
||||
return;
|
||||
};
|
||||
let original = terrain.clone();
|
||||
let mut changed = false;
|
||||
let mut requested_resolution = terrain.resolution;
|
||||
let mut remove_layer = None;
|
||||
let mut swap_layers = None;
|
||||
let mut locate_layer = None;
|
||||
let mut accepted_drop = false;
|
||||
let card = component_card_context(
|
||||
world,
|
||||
entity,
|
||||
@@ -3526,6 +3537,7 @@ fn terrain_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||||
let replacement = TerrainDesc::flat(requested_resolution);
|
||||
terrain.resolution = replacement.resolution;
|
||||
terrain.heights = replacement.heights;
|
||||
terrain.material_weights.clear();
|
||||
terrain.chunk_quads = terrain.chunk_quads.min(terrain.resolution - 1).max(1);
|
||||
changed = true;
|
||||
}
|
||||
@@ -3573,16 +3585,132 @@ fn terrain_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||||
.changed();
|
||||
});
|
||||
});
|
||||
property_row(ui, "Base Material", |ui| {
|
||||
ui.label(
|
||||
terrain
|
||||
.base_material
|
||||
.as_ref()
|
||||
.map(|material| material.label.as_str())
|
||||
.filter(|label| !label.is_empty())
|
||||
.unwrap_or("Terrain fallback"),
|
||||
);
|
||||
ui.add_space(6.0);
|
||||
ui.separator();
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(egui::RichText::new("Material Layers").strong());
|
||||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||||
if ui
|
||||
.add_enabled(
|
||||
terrain.material_layers.len() < shared::TERRAIN_MATERIAL_LAYER_LIMIT,
|
||||
egui::Button::new(phosphor_icon(icons::PLUS, 16.0)),
|
||||
)
|
||||
.on_hover_text("Add a terrain blend channel")
|
||||
.clicked()
|
||||
{
|
||||
let material = if terrain.material_layers.is_empty() {
|
||||
terrain.base_material.take()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
terrain.material_layers.push(shared::TerrainMaterialLayer {
|
||||
material,
|
||||
..Default::default()
|
||||
});
|
||||
changed = true;
|
||||
}
|
||||
});
|
||||
});
|
||||
if terrain.material_layers.is_empty() {
|
||||
ui.label(
|
||||
egui::RichText::new(
|
||||
terrain
|
||||
.base_material
|
||||
.as_ref()
|
||||
.map(|material| format!("Legacy base: {}", material.label))
|
||||
.unwrap_or_else(|| "No layers assigned; visible terrain fallback".into()),
|
||||
)
|
||||
.color(TEXT_DIM)
|
||||
.small(),
|
||||
);
|
||||
}
|
||||
for index in 0..terrain.material_layers.len() {
|
||||
ui.add_space(4.0);
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(
|
||||
egui::RichText::new(format!("Layer {}", index + 1))
|
||||
.strong()
|
||||
.color(if index == 0 {
|
||||
SELECTION_BG_MUTED
|
||||
} else {
|
||||
TEXT_DIM
|
||||
}),
|
||||
);
|
||||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||||
if icon_button_small(ui, icons::TRASH, "Remove layer").clicked() {
|
||||
remove_layer = Some(index);
|
||||
}
|
||||
if ui
|
||||
.add_enabled(
|
||||
index + 1 < terrain.material_layers.len(),
|
||||
egui::Button::new(phosphor_icon(icons::ARROW_DOWN, 15.0)).frame(false),
|
||||
)
|
||||
.on_hover_text("Move layer down")
|
||||
.clicked()
|
||||
{
|
||||
swap_layers = Some((index, index + 1));
|
||||
}
|
||||
if ui
|
||||
.add_enabled(
|
||||
index > 0,
|
||||
egui::Button::new(phosphor_icon(icons::ARROW_UP, 15.0)).frame(false),
|
||||
)
|
||||
.on_hover_text("Move layer up")
|
||||
.clicked()
|
||||
{
|
||||
swap_layers = Some((index, index - 1));
|
||||
}
|
||||
});
|
||||
});
|
||||
let response = asset_selector_row(
|
||||
ui,
|
||||
"Material",
|
||||
icons::PALETTE,
|
||||
terrain.material_layers[index].material.as_ref(),
|
||||
None,
|
||||
true,
|
||||
&material_candidates,
|
||||
material_drop_candidate.as_ref(),
|
||||
);
|
||||
if let Some(selected) = response.selected {
|
||||
terrain.material_layers[index].material = Some(selected);
|
||||
changed = true;
|
||||
}
|
||||
if response.clear {
|
||||
terrain.material_layers[index].material = None;
|
||||
changed = true;
|
||||
}
|
||||
if response.locate {
|
||||
locate_layer = Some(index);
|
||||
}
|
||||
accepted_drop |= response.accepted_drop;
|
||||
property_row(ui, "UV Tiling", |ui| {
|
||||
changed |= ui
|
||||
.add(
|
||||
egui::DragValue::new(&mut terrain.material_layers[index].uv_scale)
|
||||
.range(0.01..=1024.0)
|
||||
.speed(0.1)
|
||||
.suffix("×"),
|
||||
)
|
||||
.changed();
|
||||
});
|
||||
if !terrain.material_weights.is_empty() {
|
||||
let covered = terrain
|
||||
.material_weights
|
||||
.iter()
|
||||
.filter(|weights| weights[index] > 0)
|
||||
.count();
|
||||
ui.label(
|
||||
egui::RichText::new(format!(
|
||||
"{} / {} samples carry this layer",
|
||||
covered,
|
||||
terrain.material_weights.len()
|
||||
))
|
||||
.color(TEXT_DIM)
|
||||
.small(),
|
||||
);
|
||||
}
|
||||
}
|
||||
match terrain.validate() {
|
||||
Ok(()) => {
|
||||
ui.label(
|
||||
@@ -3602,6 +3730,31 @@ fn terrain_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||||
});
|
||||
apply_component_card_response(world, entity, card_response);
|
||||
|
||||
if let Some(index) = remove_layer {
|
||||
remove_terrain_material_layer(&mut terrain, index);
|
||||
changed = true;
|
||||
}
|
||||
if let Some((a, b)) = swap_layers {
|
||||
terrain.material_layers.swap(a, b);
|
||||
for weights in &mut terrain.material_weights {
|
||||
weights.swap(a, b);
|
||||
}
|
||||
changed = true;
|
||||
}
|
||||
if let Some(index) = locate_layer {
|
||||
locate_asset_ref(
|
||||
world,
|
||||
terrain
|
||||
.material_layers
|
||||
.get(index)
|
||||
.and_then(|layer| layer.material.as_ref()),
|
||||
&material_candidates,
|
||||
);
|
||||
}
|
||||
if accepted_drop {
|
||||
clear_asset_drag(world);
|
||||
}
|
||||
|
||||
if changed && terrain != original {
|
||||
let _ = reflected_component_transaction(
|
||||
world,
|
||||
@@ -3617,6 +3770,50 @@ fn terrain_editor_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
|
||||
}
|
||||
}
|
||||
|
||||
fn remove_terrain_material_layer(terrain: &mut TerrainDesc, index: usize) {
|
||||
if index >= terrain.material_layers.len() {
|
||||
return;
|
||||
}
|
||||
terrain.material_layers.remove(index);
|
||||
if terrain.material_layers.is_empty() {
|
||||
terrain.material_weights.clear();
|
||||
return;
|
||||
}
|
||||
for weights in &mut terrain.material_weights {
|
||||
for channel in index..3 {
|
||||
weights[channel] = weights[channel + 1];
|
||||
}
|
||||
weights[3] = 0;
|
||||
normalize_terrain_weights(weights, terrain.material_layers.len());
|
||||
}
|
||||
}
|
||||
|
||||
fn normalize_terrain_weights(weights: &mut [u8; 4], layer_count: usize) {
|
||||
for weight in weights.iter_mut().skip(layer_count) {
|
||||
*weight = 0;
|
||||
}
|
||||
let sum: u16 = weights
|
||||
.iter()
|
||||
.take(layer_count)
|
||||
.copied()
|
||||
.map(u16::from)
|
||||
.sum();
|
||||
if sum == 0 {
|
||||
*weights = [255, 0, 0, 0];
|
||||
return;
|
||||
}
|
||||
let source = *weights;
|
||||
let mut assigned = 0_u16;
|
||||
for index in 0..layer_count {
|
||||
weights[index] = ((u16::from(source[index]) * 255) / sum) as u8;
|
||||
assigned += u16::from(weights[index]);
|
||||
}
|
||||
let largest = (0..layer_count)
|
||||
.max_by_key(|index| source[*index])
|
||||
.unwrap_or(0);
|
||||
weights[largest] = weights[largest].saturating_add((255 - assigned) as u8);
|
||||
}
|
||||
|
||||
fn brush_validation_ui(ui: &mut egui::Ui, brush: &BrushDesc) {
|
||||
let report = validate_brush(brush);
|
||||
if report.diagnostics.is_empty() {
|
||||
|
||||
@@ -20,6 +20,7 @@ use crate::state::PlayPossession;
|
||||
use crate::viewport::actor_icons::ActorIconSettings;
|
||||
use crate::viewport::brush_edit::{BrushEditMode, BrushElementSelection};
|
||||
use crate::viewport::brush_tool::{BrushToolPhase, BrushToolState};
|
||||
use crate::viewport::terrain_paint::{TerrainPaintMode, TerrainPaintState};
|
||||
use crate::viewport::terrain_sculpt::{TerrainSculptMode, TerrainSculptState};
|
||||
use crate::viewport::{
|
||||
material_drop::is_surface_asset_selection, snap_translation, viewport_ground_position,
|
||||
@@ -149,6 +150,7 @@ pub fn viewport_tab_ui(
|
||||
scene_view_selection_hud(world, ui.ctx(), rect, selected_entities);
|
||||
scene_view_brush_draw_hints(world, ui.ctx(), rect);
|
||||
scene_view_terrain_sculpt_hints(world, ui.ctx(), rect);
|
||||
scene_view_terrain_paint_hints(world, ui.ctx(), rect);
|
||||
scene_view_render_badge(world, ui.ctx(), rect);
|
||||
scene_view_brush_mode_badge(world, ui.ctx(), rect);
|
||||
scene_view_volume_hud(world, ui.ctx(), rect);
|
||||
@@ -349,6 +351,52 @@ fn scene_view_terrain_sculpt_hints(world: &World, ctx: &egui::Context, scene_rec
|
||||
});
|
||||
}
|
||||
|
||||
fn scene_view_terrain_paint_hints(world: &World, ctx: &egui::Context, scene_rect: egui::Rect) {
|
||||
let Some(tool) = world.get_resource::<TerrainPaintState>() else {
|
||||
return;
|
||||
};
|
||||
if !tool.active {
|
||||
return;
|
||||
}
|
||||
egui::Area::new(egui::Id::new("scene_view_terrain_paint_hints"))
|
||||
.fixed_pos(scene_rect.left_top() + egui::vec2(8.0, 52.0))
|
||||
.interactable(false)
|
||||
.show(ctx, |ui| {
|
||||
overlay_chip_frame().show(ui, |ui| {
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(
|
||||
egui::RichText::new(format!(
|
||||
"Terrain {} • Layer {}",
|
||||
tool.mode.label(),
|
||||
tool.active_layer + 1
|
||||
))
|
||||
.color(SELECTION)
|
||||
.strong(),
|
||||
);
|
||||
ui.label(
|
||||
egui::RichText::new(format!("R {:.1}m", tool.radius))
|
||||
.color(TEXT_DIM)
|
||||
.monospace()
|
||||
.small(),
|
||||
);
|
||||
ui.label(
|
||||
egui::RichText::new(format!("S {:.0}%", tool.strength * 100.0))
|
||||
.color(SUCCESS)
|
||||
.monospace()
|
||||
.small(),
|
||||
);
|
||||
});
|
||||
ui.add_space(4.0);
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
key_hint(ui, "LMB Drag", tool.mode.label());
|
||||
key_hint(ui, "Esc", "Cancel stroke / close");
|
||||
key_hint(ui, "RMB", "Cancel stroke / close");
|
||||
key_hint(ui, "Ctrl+Z", "Undo stroke");
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
fn key_hint(ui: &mut egui::Ui, key: &str, label: &str) {
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(
|
||||
@@ -541,6 +589,24 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
|
||||
.resource::<crate::selection::SelectedEntity>()
|
||||
.0
|
||||
.filter(|entity| world.get::<shared::TerrainDesc>(*entity).is_some());
|
||||
let terrain_layer_labels = terrain_selected
|
||||
.and_then(|entity| world.get::<shared::TerrainDesc>(entity))
|
||||
.map(|terrain| {
|
||||
terrain
|
||||
.material_layers
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(index, layer)| {
|
||||
layer
|
||||
.material
|
||||
.as_ref()
|
||||
.map(|material| material.label.clone())
|
||||
.filter(|label| !label.trim().is_empty())
|
||||
.unwrap_or_else(|| format!("Layer {}", index + 1))
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
|
||||
let toolbar_response = egui::Area::new(egui::Id::new("scene_view_toolbar"))
|
||||
.fixed_pos(scene_rect.left_top() + egui::vec2(6.0, 6.0))
|
||||
@@ -672,7 +738,8 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
|
||||
}
|
||||
|
||||
let sculpt_active = world.resource::<TerrainSculptState>().active;
|
||||
if terrain_selected.is_some() || sculpt_active {
|
||||
let paint_active = world.resource::<TerrainPaintState>().active;
|
||||
if terrain_selected.is_some() || sculpt_active || paint_active {
|
||||
ui.separator();
|
||||
let stroking = world.resource::<TerrainSculptState>().is_stroking();
|
||||
let sculpt_button_clicked = tool_button_accent(
|
||||
@@ -698,6 +765,7 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
|
||||
}
|
||||
let active = state.active;
|
||||
if active {
|
||||
world.resource_mut::<TerrainPaintState>().stop();
|
||||
world.resource_mut::<BrushToolState>().cancel();
|
||||
world
|
||||
.resource_mut::<crate::operators::ActiveOperator>()
|
||||
@@ -746,6 +814,95 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
|
||||
state.strength = strength;
|
||||
state.clamp_settings();
|
||||
}
|
||||
|
||||
let paint_stroking = world.resource::<TerrainPaintState>().is_stroking();
|
||||
let can_paint = terrain_layer_labels.len() >= 2 || paint_active;
|
||||
let paint_button_clicked = ui
|
||||
.add_enabled(
|
||||
can_paint,
|
||||
egui::Button::new(phosphor_icon(icons::PAINT_BRUSH, 16.0))
|
||||
.selected(paint_active),
|
||||
)
|
||||
.on_hover_text(if can_paint {
|
||||
if paint_active {
|
||||
"Close terrain material paint tool"
|
||||
} else {
|
||||
"Paint selected terrain material layers"
|
||||
}
|
||||
} else {
|
||||
"Assign at least two terrain material layers first"
|
||||
})
|
||||
.clicked();
|
||||
if paint_button_clicked {
|
||||
world.resource_mut::<ViewportClick>().0 = None;
|
||||
}
|
||||
if paint_button_clicked && !paint_stroking {
|
||||
let layer_count = terrain_layer_labels.len();
|
||||
let state = &mut *world.resource_mut::<TerrainPaintState>();
|
||||
if state.active {
|
||||
state.stop();
|
||||
} else if let Some(entity) = terrain_selected {
|
||||
state.start(entity, layer_count);
|
||||
}
|
||||
let active = state.active;
|
||||
if active {
|
||||
world.resource_mut::<TerrainSculptState>().stop();
|
||||
world.resource_mut::<BrushToolState>().cancel();
|
||||
world
|
||||
.resource_mut::<crate::operators::ActiveOperator>()
|
||||
.status = Some(crate::operators::OperatorStatus {
|
||||
id: "terrain.paint".into(),
|
||||
label: "Terrain Paint".into(),
|
||||
phase: crate::operators::OperatorPhase::Preview,
|
||||
hint: "LMB drag paints weights; Esc or RMB cancels".into(),
|
||||
warnings: Vec::new(),
|
||||
});
|
||||
}
|
||||
}
|
||||
if paint_active {
|
||||
let mut mode = world.resource::<TerrainPaintState>().mode;
|
||||
ui.selectable_value(&mut mode, TerrainPaintMode::Paint, "Paint")
|
||||
.on_hover_text("Increase the selected layer weight");
|
||||
ui.selectable_value(&mut mode, TerrainPaintMode::Erase, "Erase")
|
||||
.on_hover_text("Reduce the selected layer weight");
|
||||
let mut active_layer =
|
||||
world.resource::<TerrainPaintState>().active_layer;
|
||||
egui::ComboBox::from_id_salt("terrain_paint_layer")
|
||||
.selected_text(
|
||||
terrain_layer_labels
|
||||
.get(active_layer)
|
||||
.cloned()
|
||||
.unwrap_or_else(|| "Layer".into()),
|
||||
)
|
||||
.show_ui(ui, |ui| {
|
||||
for (index, label) in terrain_layer_labels.iter().enumerate() {
|
||||
ui.selectable_value(&mut active_layer, index, label);
|
||||
}
|
||||
});
|
||||
let mut radius = world.resource::<TerrainPaintState>().radius;
|
||||
let mut strength = world.resource::<TerrainPaintState>().strength;
|
||||
ui.add(
|
||||
egui::DragValue::new(&mut radius)
|
||||
.range(0.25..=128.0)
|
||||
.speed(0.1)
|
||||
.prefix("R ")
|
||||
.suffix(" m"),
|
||||
)
|
||||
.on_hover_text("Brush radius");
|
||||
ui.add(
|
||||
egui::DragValue::new(&mut strength)
|
||||
.range(0.01..=1.0)
|
||||
.speed(0.02)
|
||||
.prefix("S "),
|
||||
)
|
||||
.on_hover_text("Weight strength per dab");
|
||||
let mut state = world.resource_mut::<TerrainPaintState>();
|
||||
state.mode = mode;
|
||||
state.active_layer = active_layer;
|
||||
state.radius = radius;
|
||||
state.strength = strength;
|
||||
state.clamp_settings();
|
||||
}
|
||||
}
|
||||
|
||||
let clean_game_view = world.resource::<ViewportDisplayMode>().clean_game_view;
|
||||
|
||||
@@ -12,6 +12,7 @@ pub mod render_view;
|
||||
pub mod rendering_diagnostics;
|
||||
pub mod selection;
|
||||
pub mod selection_outline;
|
||||
pub mod terrain_paint;
|
||||
pub mod terrain_sculpt;
|
||||
pub mod viewport_mode;
|
||||
pub mod visualizers;
|
||||
@@ -25,5 +26,6 @@ pub use brush_edit::{BrushEditMode, BrushEditPlugin, BrushElementSelection};
|
||||
pub use brush_tool::{BrushToolPlugin, BrushToolState};
|
||||
pub use material_drop::{MaterialDropFeedback, MaterialDropPlugin, MaterialDropState};
|
||||
pub use panel::*;
|
||||
pub use terrain_paint::{TerrainPaintMode, TerrainPaintPlugin, TerrainPaintState};
|
||||
pub use terrain_sculpt::{TerrainSculptMode, TerrainSculptPlugin, TerrainSculptState};
|
||||
pub use viewport_mode::EditorViewportMode;
|
||||
@@ -24,6 +24,7 @@ use bevy_egui::egui;
|
||||
|
||||
use crate::viewport::material_drop::{MaterialDropSet, MaterialDropState};
|
||||
use crate::viewport::scene_view_ray;
|
||||
use crate::viewport::terrain_paint::TerrainPaintState;
|
||||
use crate::viewport::terrain_sculpt::TerrainSculptState;
|
||||
|
||||
#[derive(Resource, Default, Debug, Clone, Copy)]
|
||||
@@ -52,6 +53,7 @@ struct PickTargetQueries<'w, 's> {
|
||||
editor_only: Query<'w, 's, (), With<EditorOnly>>,
|
||||
material_drop: Option<Res<'w, MaterialDropState>>,
|
||||
terrain_sculpt: Res<'w, TerrainSculptState>,
|
||||
terrain_paint: Res<'w, TerrainPaintState>,
|
||||
viewport_ui: Res<'w, ViewportUiState>,
|
||||
}
|
||||
|
||||
@@ -127,7 +129,7 @@ fn handle_pick_events(
|
||||
for _ in click_events.read() {}
|
||||
return Ok(());
|
||||
}
|
||||
if pick_targets.terrain_sculpt.active {
|
||||
if pick_targets.terrain_sculpt.active || pick_targets.terrain_paint.active {
|
||||
viewport_click.0 = None;
|
||||
for _ in click_events.read() {}
|
||||
return Ok(());
|
||||
@@ -252,8 +254,9 @@ fn cycle_overlapping_viewport_pick(
|
||||
display: Res<ViewportDisplayMode>,
|
||||
material_drop: Option<Res<MaterialDropState>>,
|
||||
terrain_sculpt: Res<TerrainSculptState>,
|
||||
terrain_paint: Res<TerrainPaintState>,
|
||||
) -> Result {
|
||||
if terrain_sculpt.active {
|
||||
if terrain_sculpt.active || terrain_paint.active {
|
||||
return Ok(());
|
||||
}
|
||||
if material_drop
|
||||
@@ -443,13 +446,18 @@ fn sync_gizmo_targets(
|
||||
display: Res<ViewportDisplayMode>,
|
||||
brush_mode: Res<BrushEditMode>,
|
||||
terrain_sculpt: Res<TerrainSculptState>,
|
||||
terrain_paint: Res<TerrainPaintState>,
|
||||
) {
|
||||
ui_state
|
||||
.selected_entities
|
||||
.retain(|entity| transforms.contains(entity) && !editor_only.contains(entity));
|
||||
selected.0 = ui_state.selected_entities.as_slice().first().copied();
|
||||
|
||||
if display.clean_game_view || brush_mode.is_element_mode() || terrain_sculpt.active {
|
||||
if display.clean_game_view
|
||||
|| brush_mode.is_element_mode()
|
||||
|| terrain_sculpt.active
|
||||
|| terrain_paint.active
|
||||
{
|
||||
for (entity, brush_element_gizmo) in &targets {
|
||||
if brush_element_gizmo.is_none() {
|
||||
commands.entity(entity).remove::<GizmoTarget>();
|
||||
@@ -503,6 +511,7 @@ mod tests {
|
||||
.init_resource::<ViewportDisplayMode>()
|
||||
.init_resource::<BrushEditMode>()
|
||||
.init_resource::<TerrainSculptState>()
|
||||
.init_resource::<TerrainPaintState>()
|
||||
.add_systems(Update, sync_gizmo_targets);
|
||||
|
||||
app.update();
|
||||
@@ -534,6 +543,30 @@ mod tests {
|
||||
.init_resource::<SelectedEntity>()
|
||||
.init_resource::<ViewportDisplayMode>()
|
||||
.init_resource::<BrushEditMode>()
|
||||
.init_resource::<TerrainPaintState>()
|
||||
.add_systems(Update, sync_gizmo_targets);
|
||||
|
||||
app.update();
|
||||
assert!(app.world().get::<GizmoTarget>(terrain).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn terrain_paint_owns_pointer_without_transform_gizmo() {
|
||||
let mut app = App::new();
|
||||
let terrain = app
|
||||
.world_mut()
|
||||
.spawn((LevelObject, Transform::default(), GizmoTarget::default()))
|
||||
.id();
|
||||
let mut ui_state = UiState::default_layout();
|
||||
ui_state.selected_entities.select_replace(terrain);
|
||||
let mut paint = TerrainPaintState::default();
|
||||
paint.start(terrain, 2);
|
||||
app.insert_resource(ui_state)
|
||||
.insert_resource(paint)
|
||||
.init_resource::<SelectedEntity>()
|
||||
.init_resource::<ViewportDisplayMode>()
|
||||
.init_resource::<BrushEditMode>()
|
||||
.init_resource::<TerrainSculptState>()
|
||||
.add_systems(Update, sync_gizmo_targets);
|
||||
|
||||
app.update();
|
||||
|
||||
@@ -0,0 +1,531 @@
|
||||
//! Modal terrain material-weight painting with exact cancel and grouped history.
|
||||
|
||||
use bevy::prelude::*;
|
||||
use bevy_egui::EguiContexts;
|
||||
use shared::{TerrainDesc, AUTHORING_COMPONENT_TERRAIN, COMPONENT_TERRAIN_DESC};
|
||||
|
||||
use super::terrain_sculpt::{active_scene_ray, smooth_falloff, terrain_ray_hit, TerrainHit};
|
||||
use crate::camera::EditorCamera;
|
||||
use crate::history::reflected_component_transaction;
|
||||
use crate::operators::{ActiveOperator, OperatorPhase, OperatorStatus};
|
||||
use crate::scene_io::SceneIo;
|
||||
use crate::selection::{SelectedEntity, ViewportClick};
|
||||
use crate::state::scene_tools_active;
|
||||
use crate::ui::UiState;
|
||||
use crate::viewport::ViewportDisplayMode;
|
||||
|
||||
const MIN_RADIUS: f32 = 0.25;
|
||||
const MAX_RADIUS: f32 = 128.0;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||||
pub enum TerrainPaintMode {
|
||||
#[default]
|
||||
Paint,
|
||||
Erase,
|
||||
}
|
||||
|
||||
impl TerrainPaintMode {
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Self::Paint => "Paint",
|
||||
Self::Erase => "Erase",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct TerrainPaintStroke {
|
||||
entity: Entity,
|
||||
original: TerrainDesc,
|
||||
last_local: Vec3,
|
||||
}
|
||||
|
||||
#[derive(Resource, Debug, Clone)]
|
||||
pub struct TerrainPaintState {
|
||||
pub active: bool,
|
||||
pub mode: TerrainPaintMode,
|
||||
pub active_layer: usize,
|
||||
pub radius: f32,
|
||||
pub strength: f32,
|
||||
hover: Option<TerrainHit>,
|
||||
stroke: Option<TerrainPaintStroke>,
|
||||
target: Option<Entity>,
|
||||
}
|
||||
|
||||
impl Default for TerrainPaintState {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
active: false,
|
||||
mode: TerrainPaintMode::Paint,
|
||||
active_layer: 1,
|
||||
radius: 4.0,
|
||||
strength: 0.35,
|
||||
hover: None,
|
||||
stroke: None,
|
||||
target: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TerrainPaintState {
|
||||
pub fn start(&mut self, target: Entity, layer_count: usize) {
|
||||
self.active = true;
|
||||
self.target = Some(target);
|
||||
self.active_layer = self.active_layer.min(layer_count.saturating_sub(1));
|
||||
}
|
||||
|
||||
pub fn stop(&mut self) {
|
||||
self.active = false;
|
||||
self.hover = None;
|
||||
self.target = None;
|
||||
}
|
||||
|
||||
pub fn is_stroking(&self) -> bool {
|
||||
self.stroke.is_some()
|
||||
}
|
||||
|
||||
pub fn clamp_settings(&mut self) {
|
||||
self.radius = self.radius.clamp(MIN_RADIUS, MAX_RADIUS);
|
||||
self.strength = self.strength.clamp(0.01, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TerrainPaintPlugin;
|
||||
|
||||
impl Plugin for TerrainPaintPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.init_resource::<TerrainPaintState>().add_systems(
|
||||
Update,
|
||||
(terrain_paint_input, draw_terrain_paint_preview)
|
||||
.chain()
|
||||
.run_if(scene_tools_active),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn terrain_paint_input(
|
||||
mut commands: Commands,
|
||||
mut state: ResMut<TerrainPaintState>,
|
||||
mut selected: ResMut<SelectedEntity>,
|
||||
keys: Res<ButtonInput<KeyCode>>,
|
||||
buttons: Res<ButtonInput<MouseButton>>,
|
||||
mut contexts: EguiContexts,
|
||||
ui_state: Res<UiState>,
|
||||
display: Res<ViewportDisplayMode>,
|
||||
cameras: Query<(&Camera, &GlobalTransform), With<EditorCamera>>,
|
||||
mut terrains: Query<(&GlobalTransform, &mut TerrainDesc)>,
|
||||
mut viewport_click: ResMut<ViewportClick>,
|
||||
mut scene_io: ResMut<SceneIo>,
|
||||
mut active_operator: ResMut<ActiveOperator>,
|
||||
) -> Result {
|
||||
if !state.active {
|
||||
return Ok(());
|
||||
}
|
||||
viewport_click.0 = None;
|
||||
state.clamp_settings();
|
||||
let Some(entity) = state.target.or(selected.0) else {
|
||||
cancel_stroke(&mut state, &mut terrains);
|
||||
state.stop();
|
||||
return Ok(());
|
||||
};
|
||||
if selected.0 != Some(entity) {
|
||||
selected.0 = Some(entity);
|
||||
}
|
||||
if display.clean_game_view {
|
||||
cancel_stroke(&mut state, &mut terrains);
|
||||
state.stop();
|
||||
return Ok(());
|
||||
}
|
||||
let ctx = contexts.ctx_mut()?;
|
||||
let cancel_requested =
|
||||
keys.just_pressed(KeyCode::Escape) || buttons.just_pressed(MouseButton::Right);
|
||||
if cancel_requested {
|
||||
if state.is_stroking() {
|
||||
cancel_stroke(&mut state, &mut terrains);
|
||||
scene_io.status = "Terrain paint stroke canceled".into();
|
||||
set_status(
|
||||
&mut active_operator,
|
||||
OperatorPhase::Canceled,
|
||||
"Weights restored",
|
||||
);
|
||||
} else {
|
||||
state.stop();
|
||||
scene_io.status = "Terrain paint tool closed".into();
|
||||
set_status(&mut active_operator, OperatorPhase::Canceled, "Tool closed");
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
let Ok((global, mut terrain)) = terrains.get_mut(entity) else {
|
||||
state.stroke = None;
|
||||
state.stop();
|
||||
return Ok(());
|
||||
};
|
||||
let layer_count = terrain.material_layers.len();
|
||||
if layer_count == 0 {
|
||||
state.stop();
|
||||
scene_io.status = "Add a terrain material layer before painting".into();
|
||||
return Ok(());
|
||||
}
|
||||
state.active_layer = state.active_layer.min(layer_count - 1);
|
||||
state.hover = ui_state
|
||||
.viewport_pointer_pos
|
||||
.and_then(|pointer| active_scene_ray(&cameras, pointer, ui_state.viewport_rect))
|
||||
.and_then(|ray| terrain_ray_hit(entity, &terrain, global, ray));
|
||||
|
||||
if buttons.just_pressed(MouseButton::Left) && !ctx.egui_wants_pointer_input() {
|
||||
if let Some(hit) = state.hover.filter(|hit| hit.entity == entity) {
|
||||
let original = terrain.clone();
|
||||
terrain.ensure_material_weights();
|
||||
apply_weight_dab(
|
||||
&mut terrain,
|
||||
hit.local,
|
||||
state.radius,
|
||||
state.strength,
|
||||
state.active_layer,
|
||||
state.mode,
|
||||
);
|
||||
state.stroke = Some(TerrainPaintStroke {
|
||||
entity,
|
||||
original,
|
||||
last_local: hit.local,
|
||||
});
|
||||
set_status(
|
||||
&mut active_operator,
|
||||
OperatorPhase::Preview,
|
||||
format!(
|
||||
"{} layer {} in progress",
|
||||
state.mode.label(),
|
||||
state.active_layer + 1
|
||||
),
|
||||
);
|
||||
}
|
||||
} else if buttons.pressed(MouseButton::Left) {
|
||||
let radius = state.radius;
|
||||
let strength = state.strength;
|
||||
let layer = state.active_layer;
|
||||
let mode = state.mode;
|
||||
if let (Some(hit), Some(stroke)) = (state.hover, state.stroke.as_mut()) {
|
||||
if hit.entity == stroke.entity {
|
||||
let step = (radius * 0.2).max(terrain.sample_spacing * 0.25);
|
||||
let delta = hit.local - stroke.last_local;
|
||||
let distance = Vec2::new(delta.x, delta.z).length();
|
||||
if distance >= step {
|
||||
let count = (distance / step).floor() as usize;
|
||||
for index in 1..=count {
|
||||
let point = stroke.last_local + delta * (index as f32 / count as f32);
|
||||
apply_weight_dab(&mut terrain, point, radius, strength, layer, mode);
|
||||
}
|
||||
stroke.last_local = hit.local;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if buttons.just_released(MouseButton::Left) {
|
||||
if let Some(stroke) = state.stroke.take() {
|
||||
let final_terrain = terrain.clone();
|
||||
let mode = state.mode;
|
||||
commands.queue(move |world: &mut World| {
|
||||
if let Err(error) = commit_paint_stroke(world, stroke, final_terrain) {
|
||||
world.resource_mut::<SceneIo>().status =
|
||||
format!("Terrain paint commit failed: {error}");
|
||||
}
|
||||
});
|
||||
scene_io.status = format!("{} terrain material weights committed", mode.label());
|
||||
set_status(
|
||||
&mut active_operator,
|
||||
OperatorPhase::Committed,
|
||||
format!("{} weights; Ctrl+Z to undo", mode.label()),
|
||||
);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn commit_paint_stroke(
|
||||
world: &mut World,
|
||||
stroke: TerrainPaintStroke,
|
||||
final_terrain: TerrainDesc,
|
||||
) -> Result<(), String> {
|
||||
if let Ok(mut actor) = world.get_entity_mut(stroke.entity) {
|
||||
actor.insert(stroke.original);
|
||||
}
|
||||
reflected_component_transaction(
|
||||
world,
|
||||
stroke.entity,
|
||||
"Paint Terrain Material",
|
||||
AUTHORING_COMPONENT_TERRAIN,
|
||||
COMPONENT_TERRAIN_DESC,
|
||||
move |world, entity| {
|
||||
world.entity_mut(entity).insert(final_terrain);
|
||||
Ok(())
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
fn cancel_stroke(
|
||||
state: &mut TerrainPaintState,
|
||||
terrains: &mut Query<(&GlobalTransform, &mut TerrainDesc)>,
|
||||
) {
|
||||
let Some(stroke) = state.stroke.take() else {
|
||||
return;
|
||||
};
|
||||
if let Ok((_, mut terrain)) = terrains.get_mut(stroke.entity) {
|
||||
*terrain = stroke.original;
|
||||
}
|
||||
}
|
||||
|
||||
fn set_status(active: &mut ActiveOperator, phase: OperatorPhase, hint: impl Into<String>) {
|
||||
active.status = Some(OperatorStatus {
|
||||
id: "terrain.paint".into(),
|
||||
label: "Terrain Paint".into(),
|
||||
phase,
|
||||
hint: hint.into(),
|
||||
warnings: Vec::new(),
|
||||
});
|
||||
}
|
||||
|
||||
fn apply_weight_dab(
|
||||
terrain: &mut TerrainDesc,
|
||||
center: Vec3,
|
||||
radius: f32,
|
||||
strength: f32,
|
||||
active_layer: usize,
|
||||
mode: TerrainPaintMode,
|
||||
) {
|
||||
terrain.ensure_material_weights();
|
||||
let layer_count = terrain.material_layers.len().clamp(1, 4);
|
||||
if active_layer >= layer_count {
|
||||
return;
|
||||
}
|
||||
let radius = radius.max(MIN_RADIUS);
|
||||
let half_extent = (terrain.resolution - 1) as f32 * terrain.sample_spacing * 0.5;
|
||||
for z in 0..terrain.resolution {
|
||||
for x in 0..terrain.resolution {
|
||||
let sample = Vec2::new(
|
||||
x as f32 * terrain.sample_spacing - half_extent,
|
||||
z as f32 * terrain.sample_spacing - half_extent,
|
||||
);
|
||||
let distance = sample.distance(Vec2::new(center.x, center.z));
|
||||
if distance > radius {
|
||||
continue;
|
||||
}
|
||||
let amount = strength.clamp(0.0, 1.0) * smooth_falloff(distance / radius);
|
||||
let index = (z * terrain.resolution + x) as usize;
|
||||
terrain.material_weights[index] = adjust_weights(
|
||||
terrain.material_weights[index],
|
||||
active_layer,
|
||||
layer_count,
|
||||
amount,
|
||||
mode,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn adjust_weights(
|
||||
weights: [u8; 4],
|
||||
active_layer: usize,
|
||||
layer_count: usize,
|
||||
amount: f32,
|
||||
mode: TerrainPaintMode,
|
||||
) -> [u8; 4] {
|
||||
let mut values = weights.map(|value| f32::from(value) / 255.0);
|
||||
for value in values.iter_mut().skip(layer_count) {
|
||||
*value = 0.0;
|
||||
}
|
||||
let current = values[active_layer];
|
||||
let target = match mode {
|
||||
TerrainPaintMode::Paint => current + (1.0 - current) * amount,
|
||||
TerrainPaintMode::Erase => current * (1.0 - amount),
|
||||
};
|
||||
let other_sum: f32 = values
|
||||
.iter()
|
||||
.take(layer_count)
|
||||
.enumerate()
|
||||
.filter(|(index, _)| *index != active_layer)
|
||||
.map(|(_, value)| *value)
|
||||
.sum();
|
||||
if other_sum <= f32::EPSILON {
|
||||
if layer_count == 1 {
|
||||
values[active_layer] = 1.0;
|
||||
} else {
|
||||
values.fill(0.0);
|
||||
values[active_layer] = target;
|
||||
let fallback = if active_layer == 0 { 1 } else { 0 };
|
||||
values[fallback] = 1.0 - target;
|
||||
}
|
||||
} else {
|
||||
let scale = (1.0 - target) / other_sum;
|
||||
for (index, value) in values.iter_mut().take(layer_count).enumerate() {
|
||||
if index != active_layer {
|
||||
*value *= scale;
|
||||
}
|
||||
}
|
||||
values[active_layer] = target;
|
||||
}
|
||||
quantize_weights(values, layer_count)
|
||||
}
|
||||
|
||||
fn quantize_weights(values: [f32; 4], layer_count: usize) -> [u8; 4] {
|
||||
let mut result = [0_u8; 4];
|
||||
let mut fractions = [(0_usize, 0.0_f32); 4];
|
||||
let mut assigned = 0_u16;
|
||||
for index in 0..layer_count {
|
||||
let scaled = values[index].clamp(0.0, 1.0) * 255.0;
|
||||
let floor = scaled.floor() as u8;
|
||||
result[index] = floor;
|
||||
assigned += u16::from(floor);
|
||||
fractions[index] = (index, scaled - f32::from(floor));
|
||||
}
|
||||
fractions[..layer_count].sort_by(|a, b| b.1.total_cmp(&a.1));
|
||||
for offset in 0..usize::from(255_u16 - assigned) {
|
||||
result[fractions[offset % layer_count].0] += 1;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn draw_terrain_paint_preview(state: Res<TerrainPaintState>, mut gizmos: Gizmos) {
|
||||
if !state.active {
|
||||
return;
|
||||
}
|
||||
let Some(hit) = state.hover else {
|
||||
return;
|
||||
};
|
||||
let color = match state.mode {
|
||||
TerrainPaintMode::Paint => Color::srgba(0.22, 0.78, 1.0, 0.95),
|
||||
TerrainPaintMode::Erase => Color::srgba(1.0, 0.64, 0.22, 0.95),
|
||||
};
|
||||
let rotation = hit.world_rotation * Quat::from_rotation_x(std::f32::consts::FRAC_PI_2);
|
||||
gizmos
|
||||
.circle(
|
||||
Isometry3d::new(hit.world + Vec3::Y * 0.035, rotation),
|
||||
state.radius,
|
||||
color,
|
||||
)
|
||||
.resolution(48);
|
||||
gizmos.sphere(
|
||||
Isometry3d::from_translation(hit.world + Vec3::Y * 0.04),
|
||||
0.06,
|
||||
color,
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::history::{apply_command_redo, apply_command_undo, EditorHistory};
|
||||
use shared::{ActorKind, LevelObject};
|
||||
|
||||
#[test]
|
||||
fn paint_and_erase_keep_weights_exactly_normalized() {
|
||||
let painted = adjust_weights([255, 0, 0, 0], 1, 2, 0.5, TerrainPaintMode::Paint);
|
||||
assert_eq!(painted.iter().copied().map(u16::from).sum::<u16>(), 255);
|
||||
assert!(painted[1] > 0);
|
||||
let erased = adjust_weights(painted, 1, 2, 1.0, TerrainPaintMode::Erase);
|
||||
assert_eq!(erased, [255, 0, 0, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dab_only_changes_samples_inside_footprint() {
|
||||
let mut terrain = TerrainDesc::flat(5);
|
||||
terrain.material_layers = vec![Default::default(), Default::default()];
|
||||
apply_weight_dab(
|
||||
&mut terrain,
|
||||
Vec3::ZERO,
|
||||
1.1,
|
||||
1.0,
|
||||
1,
|
||||
TerrainPaintMode::Paint,
|
||||
);
|
||||
assert!(terrain.material_weights[12][1] > 0);
|
||||
assert_eq!(terrain.material_weights[0], [255, 0, 0, 0]);
|
||||
assert!(terrain.validate().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_dabs_commit_as_one_undoable_paint_stroke() {
|
||||
let mut app = App::new();
|
||||
app.register_type::<ActorKind>()
|
||||
.register_type::<TerrainDesc>()
|
||||
.register_type::<shared::TerrainMaterialLayer>()
|
||||
.register_type::<shared::EditorAssetRef>();
|
||||
let world = app.world_mut();
|
||||
world.init_resource::<EditorHistory>();
|
||||
world.init_resource::<SceneIo>();
|
||||
let mut original = TerrainDesc::flat(9);
|
||||
original.material_layers = vec![Default::default(), Default::default()];
|
||||
let entity = world
|
||||
.spawn((LevelObject, ActorKind::Terrain, original.clone()))
|
||||
.id();
|
||||
let mut final_terrain = original.clone();
|
||||
for x in [-2.0, 0.0, 2.0] {
|
||||
apply_weight_dab(
|
||||
&mut final_terrain,
|
||||
Vec3::new(x, 0.0, 0.0),
|
||||
2.5,
|
||||
0.5,
|
||||
1,
|
||||
TerrainPaintMode::Paint,
|
||||
);
|
||||
}
|
||||
world.entity_mut(entity).insert(final_terrain.clone());
|
||||
commit_paint_stroke(
|
||||
world,
|
||||
TerrainPaintStroke {
|
||||
entity,
|
||||
original: original.clone(),
|
||||
last_local: Vec3::ZERO,
|
||||
},
|
||||
final_terrain.clone(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(world.resource::<EditorHistory>().undo_depth(), 1);
|
||||
assert_eq!(world.get::<TerrainDesc>(entity), Some(&final_terrain));
|
||||
apply_command_undo(world);
|
||||
assert_eq!(world.get::<TerrainDesc>(entity), Some(&original));
|
||||
apply_command_redo(world);
|
||||
assert_eq!(world.get::<TerrainDesc>(entity), Some(&final_terrain));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancel_restores_implicit_pre_stroke_weights() {
|
||||
fn cancel_once(
|
||||
mut state: ResMut<TerrainPaintState>,
|
||||
mut terrains: Query<(&GlobalTransform, &mut TerrainDesc)>,
|
||||
) {
|
||||
cancel_stroke(&mut state, &mut terrains);
|
||||
}
|
||||
|
||||
let mut app = App::new();
|
||||
let mut original = TerrainDesc::flat(5);
|
||||
original.material_layers = vec![Default::default(), Default::default()];
|
||||
let mut preview = original.clone();
|
||||
apply_weight_dab(
|
||||
&mut preview,
|
||||
Vec3::ZERO,
|
||||
3.0,
|
||||
0.8,
|
||||
1,
|
||||
TerrainPaintMode::Paint,
|
||||
);
|
||||
let entity = app
|
||||
.world_mut()
|
||||
.spawn((GlobalTransform::default(), preview))
|
||||
.id();
|
||||
let mut state = TerrainPaintState::default();
|
||||
state.start(entity, 2);
|
||||
state.stroke = Some(TerrainPaintStroke {
|
||||
entity,
|
||||
original: original.clone(),
|
||||
last_local: Vec3::ZERO,
|
||||
});
|
||||
app.insert_resource(state).add_systems(Update, cancel_once);
|
||||
|
||||
app.update();
|
||||
assert_eq!(app.world().get::<TerrainDesc>(entity), Some(&original));
|
||||
assert!(!app.world().resource::<TerrainPaintState>().is_stroking());
|
||||
}
|
||||
}
|
||||
@@ -41,11 +41,11 @@ impl TerrainSculptMode {
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
struct TerrainHit {
|
||||
entity: Entity,
|
||||
local: Vec3,
|
||||
world: Vec3,
|
||||
world_rotation: Quat,
|
||||
pub(super) struct TerrainHit {
|
||||
pub(super) entity: Entity,
|
||||
pub(super) local: Vec3,
|
||||
pub(super) world: Vec3,
|
||||
pub(super) world_rotation: Quat,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
@@ -324,7 +324,7 @@ fn sculpt_history_label(mode: TerrainSculptMode) -> &'static str {
|
||||
}
|
||||
}
|
||||
|
||||
fn active_scene_ray(
|
||||
pub(super) fn active_scene_ray(
|
||||
cameras: &Query<(&Camera, &GlobalTransform), With<EditorCamera>>,
|
||||
pointer: bevy_egui::egui::Pos2,
|
||||
scene_rect: bevy_egui::egui::Rect,
|
||||
@@ -336,7 +336,7 @@ fn active_scene_ray(
|
||||
scene_view_ray(camera, transform, pointer, scene_rect)
|
||||
}
|
||||
|
||||
fn terrain_ray_hit(
|
||||
pub(super) fn terrain_ray_hit(
|
||||
entity: Entity,
|
||||
terrain: &TerrainDesc,
|
||||
global: &GlobalTransform,
|
||||
@@ -495,7 +495,7 @@ fn apply_dab(
|
||||
}
|
||||
}
|
||||
|
||||
fn smooth_falloff(normalized_distance: f32) -> f32 {
|
||||
pub(super) fn smooth_falloff(normalized_distance: f32) -> f32 {
|
||||
let t = (1.0 - normalized_distance).clamp(0.0, 1.0);
|
||||
t * t * (3.0 - 2.0 * t)
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user