alice-sdf 6.0.0

//! Scale transform for SDFs (Deep Fried Edition)
//!
//! # Deep Fried Optimizations
//!
//! - **SIMD Vector Division**: `point / factors` uses vdivps instruction
//!   instead of 3 separate scalar divisions
//! - **Forced Inlining**: `#[inline(always)]` guarantees no call overhead
//!
//! Author: Moroya Sakamoto

use crate::compiled::real::LawMinMax;
use glam::Vec3;

/// Transform a point by inverse uniform scale for SDF evaluation
///
/// For uniform scaling, we divide the point by the scale factor,
/// then multiply the resulting distance by the scale factor.
///
/// # Arguments
/// * `point` - Query point
/// * `factor` - Scale factor
///
/// # Returns
/// (transformed_point, distance_multiplier)
#[inline(always)]
pub fn transform_scale(point: Vec3, factor: f32) -> (Vec3, f32) {
    // `p * (1/s)`: the same bits as the compiled evaluators (3.1.0)
    (point * (1.0 / factor), factor)
}

/// Transform a point by scale (forward transform)
#[inline(always)]
pub fn transform_scale_inverse(point: Vec3, factor: f32) -> Vec3 {
    point * factor
}

/// Transform a point by inverse non-uniform scale (Deep Fried)
///
/// Non-uniform scaling distorts the SDF and requires distance correction.
/// The distance should be multiplied by the minimum scale factor as an
/// approximation (this is not exact but works for raymarching).
///
/// # Deep Fried Optimization
///
/// Uses vector division `point / factors` which compiles to a single
/// vdivps SIMD instruction instead of 3 scalar divisions:
/// ```text
/// Before: point.x / factors.x, point.y / factors.y, point.z / factors.z
/// After:  point / factors  →  vdivps xmm0, xmm1
/// ```
///
/// # Arguments
/// * `point` - Query point
/// * `factors` - Scale factors for each axis (x, y, z)
///
/// # Returns
/// (transformed_point, approximate_distance_multiplier)
#[inline(always)]
pub fn transform_scale_nonuniform(point: Vec3, factors: Vec3) -> (Vec3, f32) {
    // `p * (1/s)` per component: the compiled evaluators precompute the
    // reciprocals (`Instruction::scale_nonuniform`), and the tree must be
    // bit-identical to them (3.1.0)
    let transformed = point * Vec3::new(1.0 / factors.x, 1.0 / factors.y, 1.0 / factors.z);
    let min_factor = factors.x.law_min(factors.y.law_min(factors.z));
    (transformed, min_factor)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_scale_uniform() {
        let point = Vec3::new(2.0, 4.0, 6.0);
        let (transformed, mult) = transform_scale(point, 2.0);
        assert!((transformed - Vec3::new(1.0, 2.0, 3.0)).length() < 0.0001);
        assert!((mult - 2.0).abs() < 0.0001);
    }

    #[test]
    fn test_scale_inverse() {
        let point = Vec3::new(1.0, 2.0, 3.0);
        let factor = 2.0;

        let (transformed, _) = transform_scale(point, factor);
        let restored = transform_scale_inverse(transformed, factor);

        assert!((restored - point).length() < 0.0001);
    }

    #[test]
    fn test_scale_identity() {
        let point = Vec3::new(1.0, 2.0, 3.0);
        let (transformed, mult) = transform_scale(point, 1.0);
        assert!((transformed - point).length() < 0.0001);
        assert!((mult - 1.0).abs() < 0.0001);
    }

    #[test]
    fn test_scale_nonuniform() {
        let point = Vec3::new(2.0, 4.0, 6.0);
        let factors = Vec3::new(2.0, 2.0, 3.0);
        let (transformed, mult) = transform_scale_nonuniform(point, factors);
        assert!((transformed - Vec3::new(1.0, 2.0, 2.0)).length() < 0.0001);
        assert!((mult - 2.0).abs() < 0.0001); // Min of 2, 2, 3
    }
}