sdf_primitives.h

浏览该文件的文档.

#pragma once
#include "vde/core/point.h"
#include <cmath>
#include <algorithm>
 
namespace vde::sdf {
using core::Point3D;
using core::Vector3D;
 
// ═══════════════════════════════════════════════
//  Basic Primitives
// ═══════════════════════════════════════════════
 
[[nodiscard]] inline double sphere(const Point3D& p, double radius) {
    return p.norm() - radius;
}
 
[[nodiscard]] inline double box(const Point3D& p, const Point3D& half_extents) {
    Point3D q = p.cwiseAbs() - half_extents;
    return q.cwiseMax(0.0).norm()
         + std::min(std::max({q.x(), q.y(), q.z()}), 0.0);
}
 
[[nodiscard]] inline double round_box(const Point3D& p, const Point3D& half_extents, double r) {
    Point3D q = p.cwiseAbs() - half_extents;
    return q.cwiseMax(0.0).norm()
         + std::min(std::max({q.x(), q.y(), q.z()}), 0.0)
         - r;
}
 
[[nodiscard]] inline double torus(const Point3D& p, double major_radius, double minor_radius) {
    double qx = std::sqrt(p.x() * p.x() + p.z() * p.z()) - major_radius;
    return std::sqrt(qx * qx + p.y() * p.y()) - minor_radius;
}
 
[[nodiscard]] inline double capsule(const Point3D& p, const Point3D& a, const Point3D& b, double radius) {
    Point3D pa = p - a;
    Point3D ba = b - a;
    double ba_sq = ba.squaredNorm();
    if (ba_sq < 1e-30) {
        // Degenerate to sphere
        return pa.norm() - radius;
    }
    double h = std::clamp(pa.dot(ba) / ba_sq, 0.0, 1.0);
    return (pa - ba * h).norm() - radius;
}
 
[[nodiscard]] inline double cylinder(const Point3D& p, double radius, double height) {
    double d_xz = std::sqrt(p.x() * p.x() + p.z() * p.z()) - radius;
    double d_y  = std::abs(p.y()) - height * 0.5;
    return std::min(std::max(d_xz, d_y), 0.0)
         + std::sqrt(std::max(d_xz, 0.0) * std::max(d_xz, 0.0)
                   + std::max(d_y,  0.0) * std::max(d_y,  0.0));
}
 
[[nodiscard]] inline double plane(const Point3D& p, const Vector3D& normal, double offset) {
    return p.dot(normal) - offset;
}
 
[[nodiscard]] inline double ellipsoid(const Point3D& p, const Point3D& radii) {
    Point3D pr(p.x() / radii.x(), p.y() / radii.y(), p.z() / radii.z());
    double k0 = pr.norm();
    double k1 = Point3D(p.x() / (radii.x() * radii.x()),
                         p.y() / (radii.y() * radii.y()),
                         p.z() / (radii.z() * radii.z())).norm();
    if (k1 < 1e-30) {
        // Degenerate: point at origin → distance = -min(radii)
        return -std::min({radii.x(), radii.y(), radii.z()});
    }
    return k0 * (k0 - 1.0) / k1;
}
 
// ═══════════════════════════════════════════════
//  Parametric Primitives
// ═══════════════════════════════════════════════
 
[[nodiscard]] inline double hex_prism(const Point3D& p, double radius, double height) {
    double px = std::abs(p.x());
    double pz = std::abs(p.z());
    // 2D hexagon SDF (pointy-top in XZ plane)
    double d_hex = std::max(px + pz * 0.577350269189626, pz * 1.154700538379252) - radius;
    // Extrude along Y
    return std::max(d_hex, std::abs(p.y()) - height * 0.5);
}
 
[[nodiscard]] inline double infinite_cylinder(const Point3D& p, const Vector3D& axis, double radius) {
    return p.cross(axis).norm() - radius;
}
 
[[nodiscard]] inline double wedge(const Point3D& p, double w, double h, double d) {
    Point3D q = p.cwiseAbs() - Point3D(w * 0.5, h * 0.5, d * 0.5);
    double d_box = q.cwiseMax(0.0).norm()
                 + std::min(std::max({q.x(), q.y(), q.z()}), 0.0);
    // Diagonal plane x - z ≤ 0  (i.e., z ≥ x)
    double d_cut = (p.x() - p.z()) * 0.707106781186548;  // 1/√2
    return std::max(d_box, d_cut);
}
 
// ═══════════════════════════════════════════════
//  2D Extrusions & Revolution
// ═══════════════════════════════════════════════
 
[[nodiscard]] inline double extrusion(const Point3D& /*p*/, double sdf_2d) {
    return sdf_2d;
}
 
[[nodiscard]] inline double extrusion_bounded(const Point3D& p, double sdf_2d, double half_height) {
    return std::max(sdf_2d, std::abs(p.z()) - half_height);
}
 
[[nodiscard]] inline double revolution(const Point3D& /*p*/, double sdf_2d, double /*offset*/) {
    return sdf_2d;
}
 
// ═══════════════════════════════════════════════
//  Complex Primitives (implemented in src/sdf/)
// ═══════════════════════════════════════════════
 
[[nodiscard]] double cone(const Point3D& p, double angle_rad, double height);
 
[[nodiscard]] double triangular_prism(const Point3D& p, const Point3D& a, const Point3D& b,
                                      const Point3D& c, double height);
 
[[nodiscard]] double link(const Point3D& p, double length, double major_r, double minor_r);
 
[[nodiscard]] double infinite_cone(const Point3D& p, const Point3D& apex,
                                   const Vector3D& axis, double angle_rad);
 
} // namespace vde::sdf