Add terrain material layer painting
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-07-12 21:00:13 -04:00
1 parent 293811aecd
commit d1a56f77cc
23 files changed
+1730 -62

No files matched your search

+12 -20
View File
@@ -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(())
})
}
+3
View File
@@ -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)
+206 -9
View File
@@ -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() {
+158 -1
View File
@@ -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;
+2
View File
@@ -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;
+36 -3
View File
@@ -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();
+531
View File
@@ -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());
}
}
+8 -8
View File
@@ -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)
}