use crate::ast::{Falloff, ScalarField, VectorField};
use crate::registry::{FieldDef, FieldId, FieldRegistry};
#[cfg(feature = "field-burn")]
use burn::tensor::Tensor;
#[derive(Debug, Clone, PartialEq)]
pub enum LowerError {
UnsupportedOperator(&'static str),
UnknownField(FieldId),
SampleTypeMismatch { wanted_scalar: bool },
}
#[cfg(feature = "field-burn")]
pub fn lower_scalar(
field: &ScalarField,
registry: &FieldRegistry,
xs: Tensor<1>,
ys: Tensor<1>,
time: f32,
) -> Result<Tensor<1>, LowerError> {
match field {
ScalarField::Const(c) => Ok(xs.zeros_like().add_scalar(*c)),
ScalarField::CoordX => Ok(xs),
ScalarField::CoordY => Ok(ys),
ScalarField::Time => Ok(xs.zeros_like().add_scalar(time)),
ScalarField::Add(a, b) => {
let ta = lower_scalar(a, registry, xs.clone(), ys.clone(), time)?;
let tb = lower_scalar(b, registry, xs, ys, time)?;
Ok(ta + tb)
},
ScalarField::Mul(a, b) => {
let ta = lower_scalar(a, registry, xs.clone(), ys.clone(), time)?;
let tb = lower_scalar(b, registry, xs, ys, time)?;
Ok(ta * tb)
},
ScalarField::Scale(a, k) => {
let ta = lower_scalar(a, registry, xs, ys, time)?;
Ok(ta.mul_scalar(*k))
},
ScalarField::Negate(a) => {
let ta = lower_scalar(a, registry, xs, ys, time)?;
Ok(ta.neg())
},
ScalarField::Gaussian { center, sigma } => {
let (cx, cy) = expect_const_vec(center, "Gaussian center must be ConstVec")?;
let s2 = sigma * sigma;
if s2 <= f32::EPSILON {
return Ok(xs.zeros_like());
}
let dx = xs.sub_scalar(cx);
let dy = ys.sub_scalar(cy);
let dist_sq = dx.clone() * dx + dy.clone() * dy;
Ok(dist_sq.div_scalar(-2.0 * s2).exp())
},
ScalarField::Linear { normal, offset } => {
let (nx, ny) = expect_const_vec(normal, "Linear normal must be ConstVec")?;
let result = xs.mul_scalar(nx) + ys.mul_scalar(ny);
Ok(result.add_scalar(*offset))
},
ScalarField::Sample(id) => match registry.get(*id) {
Some(FieldDef::Scalar(f)) => lower_scalar(f, registry, xs, ys, time),
Some(FieldDef::Vector(_)) => Err(LowerError::SampleTypeMismatch {
wanted_scalar: true,
}),
None => Err(LowerError::UnknownField(*id)),
},
ScalarField::Disk {
center,
radius,
falloff,
} => {
let (cx, cy) = expect_const_vec(center, "Disk center must be ConstVec")?;
if *radius <= 0.0 {
return Ok(xs.zeros_like());
}
let dx = xs.sub_scalar(cx);
let dy = ys.sub_scalar(cy);
let dist_sq = dx.clone() * dx + dy.clone() * dy;
let d = dist_sq.sqrt();
let u = d.clone().div_scalar(*radius).clamp(0.0, 1.0);
let f_val = apply_falloff_tensor(u, *falloff);
let outside = d.greater_elem(*radius);
Ok(f_val.mask_fill(outside, 0.0))
},
ScalarField::Dot(a, b) => {
let (ax, ay) = lower_vector(a, registry, xs.clone(), ys.clone(), time)?;
let (bx, by) = lower_vector(b, registry, xs, ys, time)?;
Ok(ax * bx + ay * by)
},
}
}
#[cfg(feature = "field-burn")]
fn apply_falloff_tensor(u: Tensor<1>, falloff: Falloff) -> Tensor<1> {
match falloff {
Falloff::Hard => u.zeros_like().add_scalar(1.0),
Falloff::Linear => u.neg().add_scalar(1.0),
Falloff::Smoothstep => {
let v = u.neg().add_scalar(1.0);
let v2 = v.clone() * v.clone();
let factor = v.mul_scalar(-2.0).add_scalar(3.0);
factor * v2
},
Falloff::Quadratic => {
let v = u.neg().add_scalar(1.0);
v.clone() * v
},
}
}
#[cfg(feature = "field-burn")]
pub fn lower_vector(
field: &VectorField,
registry: &FieldRegistry,
xs: Tensor<1>,
ys: Tensor<1>,
time: f32,
) -> Result<(Tensor<1>, Tensor<1>), LowerError> {
match field {
VectorField::ConstVec { x, y } => Ok((
xs.zeros_like().add_scalar(*x),
ys.zeros_like().add_scalar(*y),
)),
VectorField::Coord => Ok((xs, ys)),
VectorField::Perp(v) => {
let (vx, vy) = lower_vector(v, registry, xs, ys, time)?;
Ok((vy.neg(), vx))
},
VectorField::Add(a, b) => {
let (ax, ay) = lower_vector(a, registry, xs.clone(), ys.clone(), time)?;
let (bx, by) = lower_vector(b, registry, xs, ys, time)?;
Ok((ax + bx, ay + by))
},
VectorField::ScaleConst(v, k) => {
let (vx, vy) = lower_vector(v, registry, xs, ys, time)?;
Ok((vx.mul_scalar(*k), vy.mul_scalar(*k)))
},
VectorField::Scale(v, s) => {
let (vx, vy) = lower_vector(v, registry, xs.clone(), ys.clone(), time)?;
let scalar = lower_scalar(s, registry, xs, ys, time)?;
Ok((vx * scalar.clone(), vy * scalar))
},
VectorField::Gradient(scalar) => lower_gradient(scalar, registry, xs, ys, time),
VectorField::Sample(id) => match registry.get(*id) {
Some(FieldDef::Vector(f)) => lower_vector(f, registry, xs, ys, time),
Some(FieldDef::Scalar(_)) => Err(LowerError::SampleTypeMismatch {
wanted_scalar: false,
}),
None => Err(LowerError::UnknownField(*id)),
},
}
}
#[cfg(feature = "field-burn")]
fn lower_gradient(
scalar: &ScalarField,
registry: &FieldRegistry,
xs: Tensor<1>,
ys: Tensor<1>,
time: f32,
) -> Result<(Tensor<1>, Tensor<1>), LowerError> {
match scalar {
ScalarField::Const(_) | ScalarField::Time => Ok((xs.zeros_like(), ys.zeros_like())),
ScalarField::CoordX => Ok((xs.zeros_like().add_scalar(1.0), ys.zeros_like())),
ScalarField::CoordY => Ok((xs.zeros_like(), ys.zeros_like().add_scalar(1.0))),
ScalarField::Linear { normal, .. } => {
let (nx, ny) = expect_const_vec(normal, "Linear normal must be ConstVec")?;
Ok((
xs.zeros_like().add_scalar(nx),
ys.zeros_like().add_scalar(ny),
))
},
ScalarField::Add(a, b) => {
let (ax, ay) = lower_gradient(a, registry, xs.clone(), ys.clone(), time)?;
let (bx, by) = lower_gradient(b, registry, xs, ys, time)?;
Ok((ax + bx, ay + by))
},
ScalarField::Scale(a, k) => {
let (ax, ay) = lower_gradient(a, registry, xs, ys, time)?;
Ok((ax.mul_scalar(*k), ay.mul_scalar(*k)))
},
ScalarField::Negate(a) => {
let (ax, ay) = lower_gradient(a, registry, xs, ys, time)?;
Ok((ax.neg(), ay.neg()))
},
ScalarField::Gaussian { center, sigma } => {
let (cx, cy) = expect_const_vec(center, "Gaussian center must be ConstVec")?;
let s2 = sigma * sigma;
if s2 <= f32::EPSILON {
return Ok((xs.zeros_like(), ys.zeros_like()));
}
let dx = xs.clone().sub_scalar(cx);
let dy = ys.clone().sub_scalar(cy);
let dist_sq = dx.clone() * dx.clone() + dy.clone() * dy.clone();
let g = dist_sq.div_scalar(-2.0 * s2).exp();
let factor = g.div_scalar(-s2);
Ok((dx * factor.clone(), dy * factor))
},
ScalarField::Sample(id) => match registry.get(*id) {
Some(FieldDef::Scalar(f)) => lower_gradient(f, registry, xs, ys, time),
Some(FieldDef::Vector(_)) => Err(LowerError::SampleTypeMismatch {
wanted_scalar: true,
}),
None => Err(LowerError::UnknownField(*id)),
},
ScalarField::Mul(a, b) => {
let av = lower_scalar(a, registry, xs.clone(), ys.clone(), time)?;
let bv = lower_scalar(b, registry, xs.clone(), ys.clone(), time)?;
let (agx, agy) = lower_gradient(a, registry, xs.clone(), ys.clone(), time)?;
let (bgx, bgy) = lower_gradient(b, registry, xs, ys, time)?;
Ok((av.clone() * bgx + bv.clone() * agx, av * bgy + bv * agy))
},
ScalarField::Dot(_, _) => Err(LowerError::UnsupportedOperator("Gradient(Dot)")),
ScalarField::Disk { .. } => Err(LowerError::UnsupportedOperator("Gradient(Disk)")),
}
}
fn expect_const_vec(v: &VectorField, msg: &'static str) -> Result<(f32, f32), LowerError> {
match v {
VectorField::ConstVec { x, y } => Ok((*x, *y)),
_ => Err(LowerError::UnsupportedOperator(msg)),
}
}
#[cfg(feature = "field-burn")]
#[cfg(test)]
mod tests;
#[cfg(feature = "field-burn-wgpu")]
#[cfg(test)]
mod tests_wgpu;