neco-geometry 0.2.3

exact shape declarations and evaluation over real algebraic coordinates
Documentation
struct NecoGpuSurfaceBounds {
    minimum: vec3f,
    maximum: vec3f,
    finite: u32,
}
struct NecoSurfaceCandidateRange { lower: f32, upper: f32, valid: u32 }
fn neco_surface_candidate_next_down(value: f32) -> f32 {
    let bits = bitcast<u32>(value);
    if (bits == 0u || bits == 0x80000000u) { return bitcast<f32>(0x80800000u); }
    if ((bits >> 23u) & 255u) == 0u { return bitcast<f32>(0x80800000u); }
    let next = select(bits - 1u, bits + 1u, (bits >> 31u) != 0u);
    if ((next >> 23u) & 255u) == 0u { return bitcast<f32>(0x80800000u); }
    return bitcast<f32>(next);
}
fn neco_surface_candidate_next_up(value: f32) -> f32 {
    let bits = bitcast<u32>(value);
    if (bits == 0u || bits == 0x80000000u) { return bitcast<f32>(0x00800000u); }
    if ((bits >> 23u) & 255u) == 0u { return bitcast<f32>(0x00800000u); }
    let next = select(bits + 1u, bits - 1u, (bits >> 31u) != 0u);
    if ((next >> 23u) & 255u) == 0u { return bitcast<f32>(0x00800000u); }
    return bitcast<f32>(next);
}
fn neco_surface_candidate_range(lower: f32, upper: f32) -> NecoSurfaceCandidateRange {
    let lb = bitcast<u32>(lower);
    let ub = bitcast<u32>(upper);
    let lf = ((lb >> 23u) & 255u) != 255u;
    let uf = ((ub >> 23u) & 255u) != 255u;
    return NecoSurfaceCandidateRange(lower, upper, select(0u, 1u, lf && uf && lower <= upper));
}
fn neco_surface_candidate_point(value: f32) -> NecoSurfaceCandidateRange {
    let bits = bitcast<u32>(value);
    if ((bits >> 23u) & 255u) == 255u { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
    if (bits & 0x7fffffffu) == 0u { return neco_surface_candidate_range(0.0, 0.0); }
    if ((bits >> 23u) & 255u) == 0u {
        return neco_surface_candidate_range(bitcast<f32>(0x80800000u), bitcast<f32>(0x00800000u));
    }
    return neco_surface_candidate_range(value, value);
}
fn neco_surface_candidate_add(a: NecoSurfaceCandidateRange, b: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    if a.valid == 0u || b.valid == 0u || max(max(abs(a.lower), abs(a.upper)), max(abs(b.lower), abs(b.upper))) > 9.223372036854776e18 { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
    let lo = a.lower + b.lower;
    let hi = a.upper + b.upper;
    return neco_surface_candidate_range(neco_surface_candidate_next_down(lo), neco_surface_candidate_next_up(hi));
}
fn neco_surface_candidate_negate(a: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    if a.valid == 0u { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
    return neco_surface_candidate_range(-a.upper, -a.lower);
}
fn neco_surface_candidate_subtract(a: NecoSurfaceCandidateRange, b: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    return neco_surface_candidate_add(a, neco_surface_candidate_negate(b));
}
fn neco_surface_candidate_multiply(a: NecoSurfaceCandidateRange, b: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    if a.valid == 0u || b.valid == 0u || max(max(abs(a.lower), abs(a.upper)), max(abs(b.lower), abs(b.upper))) > 9.223372036854776e18 { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
    let p0 = a.lower * b.lower;
    let p1 = a.lower * b.upper;
    let p2 = a.upper * b.lower;
    let p3 = a.upper * b.upper;
    let low = min(min(p0, p1), min(p2, p3));
    let high = max(max(p0, p1), max(p2, p3));
    return neco_surface_candidate_range(neco_surface_candidate_next_down(low), neco_surface_candidate_next_up(high));
}
fn neco_surface_candidate_divide(a: NecoSurfaceCandidateRange, b: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    if a.valid == 0u || b.valid == 0u || b.lower <= 0.0 && b.upper >= 0.0 || min(abs(b.lower), abs(b.upper)) < bitcast<f32>(0x00800000u) || max(abs(b.lower), abs(b.upper)) > 9.223372036854776e18 { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
    let den = array<f32, 2>(b.lower, b.upper);
    let num = array<f32, 2>(a.lower, a.upper);
    var low = bitcast<f32>(0x7f7fffffu);
    var high = -bitcast<f32>(0x7f7fffffu);
    for (var i = 0u; i < 2u; i += 1u) {
        for (var j = 0u; j < 2u; j += 1u) {
            if abs(num[i]) > abs(den[j]) * 9.223372036854776e18 { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
            let q = num[i] / den[j];
            if ((bitcast<u32>(q) >> 23u) & 255u) == 255u { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
            var qlo = q;
            var qhi = q;
            for (var step = 0u; step < 6u; step += 1u) { qlo = neco_surface_candidate_next_down(qlo); qhi = neco_surface_candidate_next_up(qhi); }
            low = min(low, qlo);
            high = max(high, qhi);
        }
    }
    return neco_surface_candidate_range(low, high);
}
fn neco_surface_candidate_square(a: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    if a.valid == 0u { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
    let product = neco_surface_candidate_multiply(a, a);
    if product.valid == 0u { return product; }
    if a.lower <= 0.0 && a.upper >= 0.0 { return neco_surface_candidate_range(0.0, max(abs(product.lower), abs(product.upper))); }
    return neco_surface_candidate_range(max(0.0, product.lower), product.upper);
}
fn neco_surface_candidate_polynomial(p: NecoGpuPolynomial, u: NecoSurfaceCandidateRange, v: NecoSurfaceCandidateRange, error: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    if p.metadata.x > 16u { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
    var total = neco_surface_candidate_point(0.0);
    for (var i = 0u; i < p.metadata.x; i += 1u) {
        let term = p.terms[i];
        if term.exponent_u > 2u || term.exponent_v > 2u { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
        var up = neco_surface_candidate_point(1.0);
        var vp = neco_surface_candidate_point(1.0);
        if term.exponent_u == 1u { up = u; }
        if term.exponent_u == 2u { up = neco_surface_candidate_square(u); }
        if term.exponent_v == 1u { vp = v; }
        if term.exponent_v == 2u { vp = neco_surface_candidate_square(v); }
        let coefficient_midpoint = neco_surface_candidate_point(term.coefficient);
        let coefficient_lower = neco_surface_candidate_subtract(coefficient_midpoint, error);
        let coefficient_upper = neco_surface_candidate_add(coefficient_midpoint, error);
        if coefficient_lower.valid == 0u || coefficient_upper.valid == 0u { return NecoSurfaceCandidateRange(0.0, 0.0, 0u); }
        let coefficient = neco_surface_candidate_range(coefficient_lower.lower, coefficient_upper.upper);
        let monomial = neco_surface_candidate_multiply(neco_surface_candidate_multiply(coefficient, up), vp);
        total = neco_surface_candidate_add(total, monomial);
    }
    return total;
}
fn neco_surface_candidate_coordinate(numerator: NecoGpuPolynomial, denominator: NecoSurfaceCandidateRange, u: NecoSurfaceCandidateRange, v: NecoSurfaceCandidateRange, error: NecoSurfaceCandidateRange) -> NecoSurfaceCandidateRange {
    return neco_surface_candidate_divide(neco_surface_candidate_polynomial(numerator, u, v, error), denominator);
}
fn neco_gpu_surface_bounds(surface: NecoGpuSurface, domain: NecoGpuCrossingDomain) -> NecoGpuSurfaceBounds {
    let error = neco_surface_candidate_point(domain.encoded_error_bound);
    if error.valid == 0u || domain.encoded_error_bound < 0.0 { return NecoGpuSurfaceBounds(vec3f(0.0), vec3f(0.0), 0u); }
    let ue = neco_surface_candidate_point(domain.minimum.x);
    let ve = neco_surface_candidate_point(domain.minimum.y);
    let uw = neco_surface_candidate_point(domain.maximum.x);
    let vw = neco_surface_candidate_point(domain.maximum.y);
    let u_lower = neco_surface_candidate_subtract(ue, error);
    let v_lower = neco_surface_candidate_subtract(ve, error);
    let u_upper = neco_surface_candidate_add(uw, error);
    let v_upper = neco_surface_candidate_add(vw, error);
    if ue.valid == 0u || ve.valid == 0u || uw.valid == 0u || vw.valid == 0u || u_lower.valid == 0u || v_lower.valid == 0u || u_upper.valid == 0u || v_upper.valid == 0u { return NecoGpuSurfaceBounds(vec3f(0.0), vec3f(0.0), 0u); }
    let u = neco_surface_candidate_range(u_lower.lower, u_upper.upper);
    let v = neco_surface_candidate_range(v_lower.lower, v_upper.upper);
    if u.valid == 0u || v.valid == 0u { return NecoGpuSurfaceBounds(vec3f(0.0), vec3f(0.0), 0u); }
    let den = neco_surface_candidate_polynomial(surface.denominator, u, v, error);
    let x = neco_surface_candidate_coordinate(surface.x, den, u, v, error);
    let y = neco_surface_candidate_coordinate(surface.y, den, u, v, error);
    let z = neco_surface_candidate_coordinate(surface.z, den, u, v, error);
    if x.valid == 0u || y.valid == 0u || z.valid == 0u { return NecoGpuSurfaceBounds(vec3f(0.0), vec3f(0.0), 0u); }
    let xyz = array<NecoSurfaceCandidateRange, 3>(x, y, z);
    var lo = vec3f(0.0);
    var hi = vec3f(0.0);
    for (var axis = 0u; axis < 3u; axis += 1u) {
        if neco_surface_candidate_point(xyz[axis].lower).valid == 0u || neco_surface_candidate_point(xyz[axis].upper).valid == 0u { return NecoGpuSurfaceBounds(vec3f(0.0), vec3f(0.0), 0u); }
        lo[axis] = xyz[axis].lower;
        hi[axis] = xyz[axis].upper;
    }
    return NecoGpuSurfaceBounds(lo, hi, 1u);
}
fn neco_gpu_surface_ray_excluded(bounds: NecoGpuSurfaceBounds, ray: NecoGpuCrossingRay) -> bool {
    if bounds.finite == 0u { return false; }
    for (var axis = 0u; axis < 3u; axis += 1u) {
        let origin_exponent = (bitcast<u32>(ray.origin[axis]) >> 23u) & 255u;
        let direction_exponent = (bitcast<u32>(ray.direction[axis]) >> 23u) & 255u;
        let lower_exponent = (bitcast<u32>(bounds.minimum[axis]) >> 23u) & 255u;
        let upper_exponent = (bitcast<u32>(bounds.maximum[axis]) >> 23u) & 255u;
        if origin_exponent == 255u || direction_exponent == 255u || lower_exponent == 255u || upper_exponent == 255u { return false; }
        if !(abs(ray.origin[axis]) <= 1.0e4 && abs(ray.direction[axis]) <= 1.0e4 && bounds.minimum[axis] <= bounds.maximum[axis]) { return false; }
    }
    if dot(ray.direction.xyz, ray.direction.xyz) <= 1.0e-12 { return false; }
    var t_lower = 0.0;
    var t_upper = bitcast<f32>(0x7f7fffffu);
    for (var axis = 0u; axis < 3u; axis += 1u) {
        let direction_bits = bitcast<u32>(ray.direction[axis]) & 0x7fffffffu;
        if direction_bits == 0u {
            if ray.origin[axis] < bounds.minimum[axis] || ray.origin[axis] > bounds.maximum[axis] { return true; }
            continue;
        }
        if direction_bits < 0x00800000u { continue; }
        let a = neco_surface_candidate_subtract(neco_surface_candidate_point(bounds.minimum[axis]), neco_surface_candidate_point(ray.origin[axis]));
        let b = neco_surface_candidate_subtract(neco_surface_candidate_point(bounds.maximum[axis]), neco_surface_candidate_point(ray.origin[axis]));
        let direction = neco_surface_candidate_point(ray.direction[axis]);
        let ta = neco_surface_candidate_divide(a, direction);
        let tb = neco_surface_candidate_divide(b, direction);
        if ta.valid == 0u || tb.valid == 0u { continue; }
        let axis_lower = min(ta.lower, tb.lower);
        let axis_upper = max(ta.upper, tb.upper);
        t_lower = max(t_lower, axis_lower);
        t_upper = min(t_upper, axis_upper);
        if t_lower > t_upper { return true; }
    }
    return false;
}