Struct ThermalModifier 

pub struct ThermalModifier {
    pub config: ThermalConfig,
    pub temperature: ScalarField3D,
    pub melt_accumulator: ScalarField3D,
    pub heat_sources: Vec<HeatSource>,
    pub enabled: bool,
}

Thermal simulation that modifies SDF based on temperature

Supports melting (surface recession + gravity droop), thermal expansion, and freeze growth.

Fields

config: ThermalConfig

Configuration

temperature: ScalarField3D

Temperature field

melt_accumulator: ScalarField3D

Accumulated melt deformation (positive = material removed)

heat_sources: Vec<HeatSource>

Active heat sources

enabled: bool

Whether modifier is enabled

Implementations

impl ThermalModifier

pub fn new( config: ThermalConfig, resolution: usize, min: (f32, f32, f32), max: (f32, f32, f32), ) -> Self

Create a new thermal modifier

pub fn add_heat_point( &mut self, x: f32, y: f32, z: f32, power: f32, radius: f32, )

Add a point heat source

pub fn apply_heat_at( &mut self, x: f32, y: f32, z: f32, amount: f32, radius: f32, )

Apply heat at a position (e.g., from friction, laser, etc.)

pub fn temperature_at(&self, x: f32, y: f32, z: f32) -> f32

Get temperature at a point

impl ThermalModifier

pub const PARTICIPANT_KIND: ParticipantKind

Snapshot tag of this type as a world participant: "THRM", the four ASCII bytes read big endian. Never changes.

Trait Implementations

impl CoupledScalar for ThermalModifier

The temperature field is shared through a deterministic Fix128 channel.

ThermalModifier and crate::phase_change::PhaseChangeModifier each own a temperature field and nothing relates them — PhysicsModifier::update receives only dt, so neither can read the other’s. Going through CoupledField gives the pair one agreed field; see crate::coupled_field::reconcile_mean.

This does not change what update does: coupling happens only when the caller reconciles, so an existing chain behaves exactly as before.

fn coupled_name(&self) -> &'static str

Name of the quantity shared, for diagnostics ("temperature", …).

fn coupled_channel(&self) -> Result<CoupledField, CoupledFieldError>

A zero-filled channel on this subsystem’s grid.

fn publish(&self, out: &mut CoupledField) -> Result<(), CoupledFieldError>

Write this subsystem’s field into out.

fn adopt(&mut self, src: &CoupledField) -> Result<(), CoupledFieldError>

Replace this subsystem’s field with the channel’s contents.

fn check_adopt(&self, src: &CoupledField) -> Result<(), CoupledFieldError>

Report, without changing anything, whether Self::adopt would accept src.

impl Participant for ThermalModifier

One update(h) per world substep (h converted with Fix128::to_f32); see the module documentation of crate::sim_modifier for the payload and what is not coupled yet.

Observations: channel 0 the highest cell temperature (absent for a grid without cells), channel 1 the total melt (sum of the melt cells).

fn kind(&self) -> ParticipantKind

Snapshot tag of this participant type.

fn substep( &mut self, _ctx: &mut SubstepCtx<'_>, h: Fix128, ) -> Result<(), ParticipantFault>

Advance by one world substep of width h (ctx.h()). Read bodies from ctx, stage forces on them through ctx.

fn observe(&self, out: &mut ObservationSink)

Report observable values. The world reports them as Observed::Undecided while a fault is recorded.

fn write_state(&self, out: &mut Vec<u8>)

Append the whole state to out.

fn check_state(&self, bytes: &[u8]) -> Result<(), StateError>

Check that bytes is a payload Self::read_state can apply. Must not change self.

fn read_state(&mut self, bytes: &[u8])

Replace the state with bytes. Only called with a payload Self::check_state accepted.

fn step_rule(&self) -> StepRule

How this participant’s time step relates to the world substep.

fn ports(&self) -> &[Port]

The ports this participant reads and writes, empty by default. The world reads them once, at registration, to fix the execution order (execution_order); they must not change while the participant is registered.

impl PhysicsModifier for ThermalModifier

fn modify_distance(&self, x: f32, y: f32, z: f32, original_dist: f32) -> f32

Modify the SDF distance at a world-space point.

fn update(&mut self, dt: f32)

Advance the simulation state by dt seconds.

fn name(&self) -> &'static str

Name of this modifier (for debugging)

fn is_active(&self) -> bool

Whether this modifier has any active effect