opensubdiv_rs/sdc/
crease.rs1use super::options::{CreasingMethod, Options};
4
5pub const SHARPNESS_SMOOTH: f32 = 0.0;
7
8pub const SHARPNESS_INFINITE: f32 = 10.0;
13
14#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
17pub enum Rule {
18 Unknown,
20 Smooth,
22 Dart,
25 Crease,
27 Corner,
29}
30
31#[derive(Debug, Clone, Copy)]
37pub struct Crease {
38 options: Options,
39}
40
41impl Crease {
42 pub fn new(options: Options) -> Self {
44 Self { options }
45 }
46
47 pub fn is_sharp(sharpness: f32) -> bool {
49 sharpness > SHARPNESS_SMOOTH
50 }
51
52 pub fn is_smooth(sharpness: f32) -> bool {
54 sharpness <= SHARPNESS_SMOOTH
55 }
56
57 pub fn is_semi_sharp(sharpness: f32) -> bool {
59 (SHARPNESS_SMOOTH < sharpness) && (sharpness < SHARPNESS_INFINITE)
60 }
61
62 pub fn is_infinite(sharpness: f32) -> bool {
64 sharpness >= SHARPNESS_INFINITE
65 }
66
67 pub fn clamp(sharpness: f32) -> f32 {
69 sharpness.clamp(SHARPNESS_SMOOTH, SHARPNESS_INFINITE)
70 }
71
72 fn is_uniform(&self) -> bool {
73 self.options.creasing_method == CreasingMethod::Uniform
74 }
75
76 fn decrement_sharpness(sharpness: f32) -> f32 {
77 if Self::is_infinite(sharpness) {
78 SHARPNESS_INFINITE
79 } else if sharpness > 1.0 {
80 sharpness - 1.0
81 } else {
82 SHARPNESS_SMOOTH
83 }
84 }
85
86 pub fn subdivide_vertex_sharpness(&self, sharpness: f32) -> f32 {
90 Self::decrement_sharpness(sharpness)
91 }
92
93 pub fn subdivide_uniform_sharpness(&self, sharpness: f32) -> f32 {
96 Self::decrement_sharpness(sharpness)
97 }
98
99 pub fn subdivide_edge_sharpness_at_vertex(
107 &self,
108 edge_sharpness: f32,
109 incident_edge_sharpness: &[f32],
110 ) -> f32 {
111 if self.is_uniform() || incident_edge_sharpness.len() < 2 {
112 return Self::decrement_sharpness(edge_sharpness);
113 }
114 if Self::is_infinite(edge_sharpness) {
115 return SHARPNESS_INFINITE;
116 }
117 if Self::is_smooth(edge_sharpness) {
118 return SHARPNESS_SMOOTH;
119 }
120
121 let mut sharp_sum = 0.0f32;
128 let mut sharp_count = 0u32;
129 for &s in incident_edge_sharpness {
130 if Self::is_semi_sharp(s) {
131 sharp_sum += s;
132 sharp_count += 1;
133 }
134 }
135
136 let blended = if sharp_count > 1 {
137 let avg = (sharp_sum - edge_sharpness) / (sharp_count - 1) as f32;
139 0.75 * edge_sharpness + 0.25 * avg
140 } else {
141 edge_sharpness
142 };
143 (blended - 1.0).max(SHARPNESS_SMOOTH)
144 }
145
146 pub fn determine_vertex_vertex_rule(
150 &self,
151 vertex_sharpness: f32,
152 sharp_edge_count: usize,
153 ) -> Rule {
154 if Self::is_sharp(vertex_sharpness) {
155 return Rule::Corner;
156 }
157 match sharp_edge_count {
158 0 => Rule::Smooth,
159 1 => Rule::Dart,
160 2 => Rule::Crease,
161 _ => Rule::Corner,
162 }
163 }
164
165 pub fn compute_fractional_weight_at_vertex(
175 &self,
176 vertex_sharpness: f32,
177 child_vertex_sharpness: f32,
178 incident_edge_sharpness: &[f32],
179 child_edge_sharpness: &[f32],
180 ) -> f32 {
181 debug_assert_eq!(incident_edge_sharpness.len(), child_edge_sharpness.len());
182
183 let mut weight_sum = 0.0f32;
184 let mut count = 0u32;
185
186 if Self::is_sharp(vertex_sharpness) && Self::is_smooth(child_vertex_sharpness) {
187 weight_sum += vertex_sharpness.min(1.0);
188 count += 1;
189 }
190 for (&s, &cs) in incident_edge_sharpness.iter().zip(child_edge_sharpness) {
191 if Self::is_sharp(s) && Self::is_smooth(cs) {
192 weight_sum += s.min(1.0);
193 count += 1;
194 }
195 }
196 if count == 0 {
197 1.0
198 } else {
199 weight_sum / count as f32
200 }
201 }
202
203 pub(crate) fn sharpen_boundary_edge(&self, sharpness: f32) -> f32 {
206 use super::options::VtxBoundaryInterpolation::*;
207 match self.options.vtx_boundary_interpolation {
208 None => sharpness,
209 EdgeOnly | EdgeAndCorner => SHARPNESS_INFINITE,
210 }
211 }
212
213 pub(crate) fn sharpen_boundary_corner_vertex(&self, sharpness: f32) -> f32 {
214 use super::options::VtxBoundaryInterpolation::*;
215 match self.options.vtx_boundary_interpolation {
216 None | EdgeOnly => sharpness,
217 EdgeAndCorner => SHARPNESS_INFINITE,
218 }
219 }
220}
221
222#[cfg(test)]
223mod tests {
224 use super::*;
225
226 #[test]
227 fn uniform_subdivision_decrements() {
228 let c = Crease::new(Options::default());
229 assert_eq!(c.subdivide_vertex_sharpness(2.5), 1.5);
230 assert_eq!(c.subdivide_vertex_sharpness(0.5), 0.0);
231 assert_eq!(
232 c.subdivide_vertex_sharpness(SHARPNESS_INFINITE),
233 SHARPNESS_INFINITE
234 );
235 }
236
237 #[test]
238 fn chaikin_averages_neighbors() {
239 let opts = Options::default().with_creasing_method(CreasingMethod::Chaikin);
240 let c = Crease::new(opts);
241 let s = c.subdivide_edge_sharpness_at_vertex(2.0, &[2.0, 4.0, 0.0, 0.0]);
244 assert!((s - 1.5).abs() < 1e-6);
245 }
246
247 #[test]
248 fn chaikin_ignores_infinitely_sharp_neighbors() {
249 let opts = Options::default().with_creasing_method(CreasingMethod::Chaikin);
250 let c = Crease::new(opts);
251 let s = c.subdivide_edge_sharpness_at_vertex(
255 2.0,
256 &[2.0, SHARPNESS_INFINITE, SHARPNESS_INFINITE],
257 );
258 assert!((s - 1.0).abs() < 1e-6);
259 let s = c.subdivide_edge_sharpness_at_vertex(
262 2.0,
263 &[2.0, SHARPNESS_INFINITE, 4.0, 0.0, SHARPNESS_INFINITE],
264 );
265 assert!((s - 1.5).abs() < 1e-6);
266 }
267
268 #[test]
269 fn rules() {
270 let c = Crease::new(Options::default());
271 assert_eq!(c.determine_vertex_vertex_rule(0.0, 0), Rule::Smooth);
272 assert_eq!(c.determine_vertex_vertex_rule(0.0, 1), Rule::Dart);
273 assert_eq!(c.determine_vertex_vertex_rule(0.0, 2), Rule::Crease);
274 assert_eq!(c.determine_vertex_vertex_rule(0.0, 3), Rule::Corner);
275 assert_eq!(c.determine_vertex_vertex_rule(1.0, 0), Rule::Corner);
276 }
277
278 #[test]
279 fn fractional_weight() {
280 let c = Crease::new(Options::default());
281 let w = c.compute_fractional_weight_at_vertex(0.0, 0.0, &[0.5, 0.5, 0.0], &[0.0, 0.0, 0.0]);
284 assert!((w - 0.5).abs() < 1e-6);
285 }
286}