SDF Module

import SDF

struct Ray {
    float3 origin;
    float3 direction;
};

struct RaymarchResult {
    bool hit;
    int steps;
    float distance;
    float3 position;
    float surfaceDistance;
};

enum SDFShape {
    Sphere(float radius),
    Box(float3 halfExtents),
    RoundBox(float3 halfExtents, float radius),
    Torus(float majorRadius, float minorRadius),
    Capsule(float3 a, float3 b, float radius),
    Cylinder(float radius, float halfHeight),
    Plane(float3 normal, float offset),

    /// Evaluates signed distance for this shape at point p.
    eval distance :: (float3 p) -> float {
        Sphere(radius): sd_sphere(p, radius)
        Box(halfExtents): sd_box(p, halfExtents)
        RoundBox(halfExtents, radius): sd_round_box(p, halfExtents, radius)
        Torus(majorRadius, minorRadius): sd_torus(p, majorRadius, minorRadius)
        Capsule(a, b, radius): sd_capsule(p, a, b, radius)
        Cylinder(radius, halfHeight): sd_cylinder(p, radius, halfHeight)
        Plane(normal, offset): sd_plane(p, normal, offset)
    }

    /// Estimates a normal from central differences.
    eval normal :: (float3 p, float eps) -> float3 {
        float3 ex = float3(eps, 0.0, 0.0);
        float3 ey = float3(0.0, eps, 0.0);
        float3 ez = float3(0.0, 0.0, eps);
        return Math::safe_normalize(float3(
            self.distance(p + ex) - self.distance(p - ex),
            self.distance(p + ey) - self.distance(p - ey),
            self.distance(p + ez) - self.distance(p - ez)
        ));
    }
}

enum SDFCombineOp : int {
    Union = 0,
    Intersection = 1,
    Subtract = 2,
    SmoothUnion = 3,
    SmoothIntersection = 4,
    SmoothSubtract = 5
}