use super::options::{CreasingMethod, Options};
pub const SHARPNESS_SMOOTH: f32 = 0.0;
pub const SHARPNESS_INFINITE: f32 = 10.0;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Rule {
Unknown,
Smooth,
Dart,
Crease,
Corner,
}
#[derive(Debug, Clone, Copy)]
pub struct Crease {
options: Options,
}
impl Crease {
pub fn new(options: Options) -> Self {
Self { options }
}
pub fn is_sharp(sharpness: f32) -> bool {
sharpness > SHARPNESS_SMOOTH
}
pub fn is_smooth(sharpness: f32) -> bool {
sharpness <= SHARPNESS_SMOOTH
}
pub fn is_semi_sharp(sharpness: f32) -> bool {
(SHARPNESS_SMOOTH < sharpness) && (sharpness < SHARPNESS_INFINITE)
}
pub fn is_infinite(sharpness: f32) -> bool {
sharpness >= SHARPNESS_INFINITE
}
pub fn clamp(sharpness: f32) -> f32 {
sharpness.clamp(SHARPNESS_SMOOTH, SHARPNESS_INFINITE)
}
fn is_uniform(&self) -> bool {
self.options.creasing_method == CreasingMethod::Uniform
}
fn decrement_sharpness(sharpness: f32) -> f32 {
if Self::is_infinite(sharpness) {
SHARPNESS_INFINITE
} else if sharpness > 1.0 {
sharpness - 1.0
} else {
SHARPNESS_SMOOTH
}
}
pub fn subdivide_vertex_sharpness(&self, sharpness: f32) -> f32 {
Self::decrement_sharpness(sharpness)
}
pub fn subdivide_uniform_sharpness(&self, sharpness: f32) -> f32 {
Self::decrement_sharpness(sharpness)
}
pub fn subdivide_edge_sharpness_at_vertex(
&self,
edge_sharpness: f32,
incident_edge_sharpness: &[f32],
) -> f32 {
if self.is_uniform() || incident_edge_sharpness.len() < 2 {
return Self::decrement_sharpness(edge_sharpness);
}
if Self::is_infinite(edge_sharpness) {
return SHARPNESS_INFINITE;
}
if Self::is_smooth(edge_sharpness) {
return SHARPNESS_SMOOTH;
}
let mut sharp_sum = 0.0f32;
let mut sharp_count = 0u32;
for &s in incident_edge_sharpness {
if Self::is_semi_sharp(s) {
sharp_sum += s;
sharp_count += 1;
}
}
let blended = if sharp_count > 1 {
let avg = (sharp_sum - edge_sharpness) / (sharp_count - 1) as f32;
0.75 * edge_sharpness + 0.25 * avg
} else {
edge_sharpness
};
(blended - 1.0).max(SHARPNESS_SMOOTH)
}
pub fn determine_vertex_vertex_rule(
&self,
vertex_sharpness: f32,
sharp_edge_count: usize,
) -> Rule {
if Self::is_sharp(vertex_sharpness) {
return Rule::Corner;
}
match sharp_edge_count {
0 => Rule::Smooth,
1 => Rule::Dart,
2 => Rule::Crease,
_ => Rule::Corner,
}
}
pub fn compute_fractional_weight_at_vertex(
&self,
vertex_sharpness: f32,
child_vertex_sharpness: f32,
incident_edge_sharpness: &[f32],
child_edge_sharpness: &[f32],
) -> f32 {
debug_assert_eq!(incident_edge_sharpness.len(), child_edge_sharpness.len());
let mut weight_sum = 0.0f32;
let mut count = 0u32;
if Self::is_sharp(vertex_sharpness) && Self::is_smooth(child_vertex_sharpness) {
weight_sum += vertex_sharpness.min(1.0);
count += 1;
}
for (&s, &cs) in incident_edge_sharpness.iter().zip(child_edge_sharpness) {
if Self::is_sharp(s) && Self::is_smooth(cs) {
weight_sum += s.min(1.0);
count += 1;
}
}
if count == 0 {
1.0
} else {
weight_sum / count as f32
}
}
pub(crate) fn sharpen_boundary_edge(&self, sharpness: f32) -> f32 {
use super::options::VtxBoundaryInterpolation::*;
match self.options.vtx_boundary_interpolation {
None => sharpness,
EdgeOnly | EdgeAndCorner => SHARPNESS_INFINITE,
}
}
pub(crate) fn sharpen_boundary_corner_vertex(&self, sharpness: f32) -> f32 {
use super::options::VtxBoundaryInterpolation::*;
match self.options.vtx_boundary_interpolation {
None | EdgeOnly => sharpness,
EdgeAndCorner => SHARPNESS_INFINITE,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn uniform_subdivision_decrements() {
let c = Crease::new(Options::default());
assert_eq!(c.subdivide_vertex_sharpness(2.5), 1.5);
assert_eq!(c.subdivide_vertex_sharpness(0.5), 0.0);
assert_eq!(
c.subdivide_vertex_sharpness(SHARPNESS_INFINITE),
SHARPNESS_INFINITE
);
}
#[test]
fn chaikin_averages_neighbors() {
let opts = Options::default().with_creasing_method(CreasingMethod::Chaikin);
let c = Crease::new(opts);
let s = c.subdivide_edge_sharpness_at_vertex(2.0, &[2.0, 4.0, 0.0, 0.0]);
assert!((s - 1.5).abs() < 1e-6);
}
#[test]
fn chaikin_ignores_infinitely_sharp_neighbors() {
let opts = Options::default().with_creasing_method(CreasingMethod::Chaikin);
let c = Crease::new(opts);
let s = c.subdivide_edge_sharpness_at_vertex(
2.0,
&[2.0, SHARPNESS_INFINITE, SHARPNESS_INFINITE],
);
assert!((s - 1.0).abs() < 1e-6);
let s = c.subdivide_edge_sharpness_at_vertex(
2.0,
&[2.0, SHARPNESS_INFINITE, 4.0, 0.0, SHARPNESS_INFINITE],
);
assert!((s - 1.5).abs() < 1e-6);
}
#[test]
fn rules() {
let c = Crease::new(Options::default());
assert_eq!(c.determine_vertex_vertex_rule(0.0, 0), Rule::Smooth);
assert_eq!(c.determine_vertex_vertex_rule(0.0, 1), Rule::Dart);
assert_eq!(c.determine_vertex_vertex_rule(0.0, 2), Rule::Crease);
assert_eq!(c.determine_vertex_vertex_rule(0.0, 3), Rule::Corner);
assert_eq!(c.determine_vertex_vertex_rule(1.0, 0), Rule::Corner);
}
#[test]
fn fractional_weight() {
let c = Crease::new(Options::default());
let w = c.compute_fractional_weight_at_vertex(0.0, 0.0, &[0.5, 0.5, 0.0], &[0.0, 0.0, 0.0]);
assert!((w - 0.5).abs() < 1e-6);
}
}