use super::gregory::{self, corner_span, is_edge_singular, vertex_rule, SparsePoint};
use super::loop_patch::{self, NUM_GREGORY_TRI_POINTS};
use super::primvar_refiner::Primvar;
use super::ptex::PtexIndices;
use super::topology_refiner::TopologyRefiner;
use crate::sdc::{Crease, FVarLinearInterpolation, Rule, SchemeType, Split};
use crate::vtr::{Level, TopologyError};
use crate::{Index, INDEX_INVALID};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PatchType {
Regular,
GregoryBasis,
Quads,
Loop,
GregoryTriangle,
Triangles,
}
#[derive(Debug, Clone, Copy)]
pub struct PatchParam {
pub ptex_face: Index,
pub depth: u8,
pub rotation: u8,
pub origin: [f32; 2],
pub triangular: bool,
}
impl PatchParam {
pub const MAX_DEPTH: u8 = 12;
pub fn normalize(&self, u: f32, v: f32) -> (f32, f32) {
let scale = (1u32 << self.depth) as f32;
let x = (u - self.origin[0]) * scale;
let y = (v - self.origin[1]) * scale;
rotate_ccw((4 - self.rotation as u32) % 4, x, y)
}
pub fn unnormalize(&self, s: f32, t: f32) -> (f32, f32) {
let scale = 1.0 / (1u32 << self.depth) as f32;
let (x, y) = rotate_ccw(self.rotation as u32, s, t);
(self.origin[0] + x * scale, self.origin[1] + y * scale)
}
pub fn is_triangle_rotated(&self) -> bool {
self.triangular && self.rotation == 2
}
fn derivative_matrix(&self) -> [f32; 4] {
let s = (1u32 << self.depth) as f32;
match self.rotation % 4 {
0 => [s, 0.0, 0.0, s],
1 => [0.0, s, -s, 0.0],
2 => [-s, 0.0, 0.0, -s],
_ => [0.0, -s, s, 0.0],
}
}
}
#[derive(Debug, Clone, Copy)]
struct PackedPatchParam(u64);
impl PackedPatchParam {
const CELL_BITS: u32 = 12;
fn pack(param: &PatchParam) -> Option<Self> {
if param.depth > PatchParam::MAX_DEPTH {
return None;
}
let scale = (1u32 << param.depth) as f32;
let corner = CORNER_UV[param.rotation as usize % 4];
let cell = [0, 1].map(|k| (param.origin[k] * scale - corner[k]) as u64);
debug_assert!(cell.iter().all(|&c| c < 1 << param.depth));
let high = param.depth as u64
| (param.rotation as u64 % 4) << 4
| (param.triangular as u64) << 6
| cell[0] << 7
| cell[1] << (7 + Self::CELL_BITS);
Some(Self(param.ptex_face as u64 | high << 32))
}
fn unpack(self) -> PatchParam {
let high = self.0 >> 32;
let depth = (high & 0xf) as u8;
let rotation = ((high >> 4) & 0x3) as u8;
let mask = (1u64 << Self::CELL_BITS) - 1;
let cell = [(high >> 7) & mask, (high >> (7 + Self::CELL_BITS)) & mask];
let scale = (1u32 << depth) as f32;
let corner = CORNER_UV[rotation as usize];
PatchParam {
ptex_face: self.0 as Index,
depth,
rotation,
origin: [0, 1].map(|k| (cell[k] as f32 + corner[k]) / scale),
triangular: (high >> 6) & 1 != 0,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct PatchBasis {
pub indices: Vec<Index>,
pub weights: Vec<f32>,
pub du_weights: Vec<f32>,
pub dv_weights: Vec<f32>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ArrayKind {
Regular,
SingleCrease,
Gregory,
Quads,
Loop,
GregoryTriangle,
Triangles,
}
impl ArrayKind {
const ALL: [ArrayKind; 7] = [
ArrayKind::Regular,
ArrayKind::SingleCrease,
ArrayKind::Gregory,
ArrayKind::Quads,
ArrayKind::Loop,
ArrayKind::GregoryTriangle,
ArrayKind::Triangles,
];
fn num_cvs(self) -> usize {
match self {
ArrayKind::Regular | ArrayKind::SingleCrease => 16,
ArrayKind::Loop => 12,
ArrayKind::Quads => 4,
ArrayKind::Triangles => 3,
ArrayKind::Gregory | ArrayKind::GregoryTriangle => 0,
}
}
fn patch_type(self) -> PatchType {
match self {
ArrayKind::Regular | ArrayKind::SingleCrease => PatchType::Regular,
ArrayKind::Gregory => PatchType::GregoryBasis,
ArrayKind::Quads => PatchType::Quads,
ArrayKind::Loop => PatchType::Loop,
ArrayKind::GregoryTriangle => PatchType::GregoryTriangle,
ArrayKind::Triangles => PatchType::Triangles,
}
}
}
#[derive(Debug, Clone, Copy)]
struct PatchArray {
kind: ArrayKind,
start: usize,
first_cv: usize,
first_aux: usize,
}
pub(crate) enum PatchRef<'a> {
Regular(&'a [Index; 16]),
SingleCrease {
cvs: &'a [Index; 16],
edge: u8,
sharpness: f32,
},
Gregory(LocalPointRange),
Quads(&'a [Index; 4]),
Loop(&'a [Index; 12]),
GregoryTriangle(LocalPointRange),
Triangles(&'a [Index; 3]),
}
#[derive(Debug, Clone, Copy)]
pub(crate) enum LocalPointRange {
Compact {
support: usize,
first_point: usize,
first_entry: usize,
support_len: u8,
},
Wide(usize),
}
const MAX_COMPACT_SUPPORT: usize = u8::MAX as usize;
#[derive(Debug, Clone, Default)]
struct LocalPoints {
support: Vec<Index>,
sizes: Vec<u8>,
slots: Vec<u8>,
weights: Vec<f32>,
wide: Vec<Box<[SparsePoint]>>,
}
impl LocalPoints {
fn push(&mut self, points: &[SparsePoint], map: impl Fn(Index) -> Index) -> LocalPointRange {
let support = self.support.len();
let first_point = self.sizes.len();
let first_entry = self.slots.len();
'compact: {
for point in points {
let start = self.slots.len();
for &(cv, w) in point.0.iter().filter(|&&(_, w)| w != 0.0) {
let cv = map(cv);
let slot = match self.support[support..].iter().position(|&s| s == cv) {
Some(slot) => slot,
None if self.support.len() - support < MAX_COMPACT_SUPPORT => {
self.support.push(cv);
self.support.len() - support - 1
}
None => break 'compact,
};
match self.slots[start..].iter().position(|&s| s as usize == slot) {
Some(entry) => self.weights[start + entry] += w,
None => {
self.slots.push(slot as u8);
self.weights.push(w);
}
}
}
self.sizes.push((self.slots.len() - start) as u8);
}
return LocalPointRange::Compact {
support,
first_point,
first_entry,
support_len: (self.support.len() - support) as u8,
};
}
self.support.truncate(support);
self.sizes.truncate(first_point);
self.slots.truncate(first_entry);
self.weights.truncate(first_entry);
let nonzero = |point: &SparsePoint| {
let mut mapped = SparsePoint::default();
for &(cv, w) in point.0.iter().filter(|&&(_, w)| w != 0.0) {
mapped.add(map(cv), w);
}
mapped
};
self.wide.push(points.iter().map(nonzero).collect());
LocalPointRange::Wide(self.wide.len() - 1)
}
fn for_each_entry(
&self,
range: LocalPointRange,
count: usize,
mut f: impl FnMut(usize, Index, f32),
) {
match range {
LocalPointRange::Compact {
support,
first_point,
first_entry,
..
} => {
let support = &self.support[support..];
let mut entry = first_entry;
let sizes = &self.sizes[first_point..first_point + count];
for (point, &size) in sizes.iter().enumerate() {
let entries = entry..entry + size as usize;
for (&slot, &w) in self.slots[entries.clone()]
.iter()
.zip(&self.weights[entries])
{
f(point, support[slot as usize], w);
}
entry += size as usize;
}
}
LocalPointRange::Wide(patch) => {
for (point, stencil) in self.wide[patch].iter().enumerate() {
for &(cv, w) in &stencil.0 {
f(point, cv, w);
}
}
}
}
}
fn support(&self, range: LocalPointRange, count: usize) -> Vec<Index> {
if let LocalPointRange::Compact {
support,
support_len,
..
} = range
{
return self.support[support..support + support_len as usize].to_vec();
}
let mut cvs: Vec<Index> = Vec::new();
self.for_each_entry(range, count, |_, cv, _| {
if !cvs.contains(&cv) {
cvs.push(cv);
}
});
cvs
}
fn shrink_to_fit(&mut self) {
self.support.shrink_to_fit();
self.sizes.shrink_to_fit();
self.slots.shrink_to_fit();
self.weights.shrink_to_fit();
self.wide.shrink_to_fit();
}
}
#[derive(Debug, Clone, Default)]
struct PatchArrays {
arrays: Vec<PatchArray>,
cvs: Vec<Index>,
creases: Vec<(f32, u8)>,
end_caps: Vec<LocalPointRange>,
local_points: LocalPoints,
}
impl PatchArrays {
fn patch_ref(&self, array: &PatchArray, offset: usize) -> PatchRef<'_> {
let num_cvs = array.kind.num_cvs();
let first = array.first_cv + offset * num_cvs;
let cvs = &self.cvs[first..first + num_cvs];
let aux = array.first_aux + offset;
match array.kind {
ArrayKind::Regular => PatchRef::Regular(cvs.try_into().unwrap()),
ArrayKind::SingleCrease => {
let (sharpness, edge) = self.creases[aux];
PatchRef::SingleCrease {
cvs: cvs.try_into().unwrap(),
edge,
sharpness,
}
}
ArrayKind::Gregory => PatchRef::Gregory(self.end_caps[aux]),
ArrayKind::Quads => PatchRef::Quads(cvs.try_into().unwrap()),
ArrayKind::Loop => PatchRef::Loop(cvs.try_into().unwrap()),
ArrayKind::GregoryTriangle => PatchRef::GregoryTriangle(self.end_caps[aux]),
ArrayKind::Triangles => PatchRef::Triangles(cvs.try_into().unwrap()),
}
}
fn vertices(&self, patch: PatchRef<'_>) -> Vec<Index> {
match patch {
PatchRef::Regular(cvs) => cvs
.iter()
.copied()
.filter(|&cv| cv != INDEX_INVALID)
.collect(),
PatchRef::Loop(cvs) => cvs
.iter()
.copied()
.filter(|&cv| cv != INDEX_INVALID)
.collect(),
PatchRef::SingleCrease { cvs, .. } => cvs.to_vec(),
PatchRef::Quads(cvs) => cvs.to_vec(),
PatchRef::Triangles(cvs) => cvs.to_vec(),
PatchRef::Gregory(range) => self.local_points.support(range, gregory::NUM_POINTS),
PatchRef::GregoryTriangle(range) => {
self.local_points.support(range, NUM_GREGORY_TRI_POINTS)
}
}
}
fn evaluate_basis(
&self,
patch: PatchRef<'_>,
param: &PatchParam,
u: f32,
v: f32,
) -> PatchBasis {
let (s, t) = param.normalize(u, v);
let m = param.derivative_matrix();
let mut basis = PatchBasis::default();
let mut push = |cv: Index, w: f32, ws: f32, wt: f32| {
let du = ws * m[0] + wt * m[2];
let dv = ws * m[1] + wt * m[3];
match basis.indices.iter().position(|&i| i == cv) {
Some(k) => {
basis.weights[k] += w;
basis.du_weights[k] += du;
basis.dv_weights[k] += dv;
}
None => {
basis.indices.push(cv);
basis.weights.push(w);
basis.du_weights.push(du);
basis.dv_weights.push(dv);
}
}
};
match patch {
PatchRef::Regular(cvs) => {
let (bu, dbu) = bspline_basis(s);
let (bv, dbv) = bspline_basis(t);
let mut w = [0.0f32; 16];
let mut ws = [0.0f32; 16];
let mut wt = [0.0f32; 16];
for j in 0..4 {
for i in 0..4 {
w[4 * j + i] = bu[i] * bv[j];
ws[4 * j + i] = dbu[i] * bv[j];
wt[4 * j + i] = bu[i] * dbv[j];
}
}
fold_phantom_weights(cvs, &mut w);
fold_phantom_weights(cvs, &mut ws);
fold_phantom_weights(cvs, &mut wt);
for (slot, &cv) in cvs.iter().enumerate() {
if cv == INDEX_INVALID {
debug_assert!(w[slot] == 0.0 && ws[slot] == 0.0 && wt[slot] == 0.0);
continue;
}
push(cv, w[slot], ws[slot], wt[slot]);
}
}
PatchRef::SingleCrease {
cvs,
edge,
sharpness,
} => {
let (bu, dbu) = match edge {
3 => crease_basis_oriented(s, sharpness, false),
1 => crease_basis_oriented(s, sharpness, true),
_ => bspline_basis(s),
};
let (bv, dbv) = match edge {
0 => crease_basis_oriented(t, sharpness, false),
2 => crease_basis_oriented(t, sharpness, true),
_ => bspline_basis(t),
};
for j in 0..4 {
for i in 0..4 {
push(
cvs[4 * j + i],
bu[i] * bv[j],
dbu[i] * bv[j],
bu[i] * dbv[j],
);
}
}
}
PatchRef::Quads(cvs) => {
let w = [(1.0 - s) * (1.0 - t), s * (1.0 - t), s * t, (1.0 - s) * t];
let ws = [-(1.0 - t), 1.0 - t, t, -t];
let wt = [-(1.0 - s), -s, s, 1.0 - s];
for (slot, &cv) in cvs.iter().enumerate() {
push(cv, w[slot], ws[slot], wt[slot]);
}
}
PatchRef::Gregory(range) => {
let (w20, ws20, wt20) = gregory::evaluate_basis(s, t);
self.local_points
.for_each_entry(range, gregory::NUM_POINTS, |point, cv, sw| {
push(cv, w20[point] * sw, ws20[point] * sw, wt20[point] * sw);
});
}
PatchRef::Loop(cvs) => {
let (mut w, mut ws, mut wt) = loop_patch::box_spline_basis(s, t);
loop_patch::fold_phantom_weights(cvs, &mut w);
loop_patch::fold_phantom_weights(cvs, &mut ws);
loop_patch::fold_phantom_weights(cvs, &mut wt);
for (slot, &cv) in cvs.iter().enumerate() {
if cv == INDEX_INVALID {
debug_assert!(w[slot] == 0.0 && ws[slot] == 0.0 && wt[slot] == 0.0);
continue;
}
push(cv, w[slot], ws[slot], wt[slot]);
}
}
PatchRef::GregoryTriangle(range) => {
let (w18, ws18, wt18) = loop_patch::evaluate_basis(s, t);
self.local_points
.for_each_entry(range, NUM_GREGORY_TRI_POINTS, |point, cv, sw| {
push(cv, w18[point] * sw, ws18[point] * sw, wt18[point] * sw);
});
}
PatchRef::Triangles(cvs) => {
let w = [1.0 - s - t, s, t];
let ws = [-1.0, 1.0, 0.0];
let wt = [-1.0, 0.0, 1.0];
for (slot, &cv) in cvs.iter().enumerate() {
push(cv, w[slot], ws[slot], wt[slot]);
}
}
}
basis
}
}
#[derive(Debug, Clone)]
struct FVarPatches {
channel: usize,
linear_interpolation: FVarLinearInterpolation,
num_values: usize,
patches: PatchArrays,
arrays: Vec<u8>,
offsets: Vec<u32>,
}
impl FVarPatches {
fn locate(&self, patch: usize) -> (&PatchArray, usize) {
if self.offsets.is_empty() {
(&self.patches.arrays[0], patch)
} else {
let array = &self.patches.arrays[self.arrays[patch] as usize];
(array, self.offsets[patch] as usize)
}
}
fn patch_ref(&self, patch: usize) -> PatchRef<'_> {
let (array, offset) = self.locate(patch);
self.patches.patch_ref(array, offset)
}
}
#[derive(Debug, Clone)]
pub struct PatchTable {
patches: PatchArrays,
params: Vec<PackedPatchParam>,
faces: Vec<Index>,
face_to_patch: Vec<Vec<Index>>,
ptex: PtexIndices,
max_level: usize,
first_child: Vec<Vec<Index>>,
num_control_values: usize,
triangular: bool,
fvar: Vec<FVarPatches>,
}
impl PatchTable {
pub fn num_patches(&self) -> usize {
self.params.len()
}
fn locate(&self, patch: usize) -> (&PatchArray, usize) {
assert!(
patch < self.num_patches(),
"patch {patch} out of range ({} patches)",
self.num_patches()
);
let array = self
.patches
.arrays
.iter()
.rfind(|array| array.start <= patch)
.expect("a non-empty table has an array starting at patch 0");
(array, patch - array.start)
}
pub(crate) fn patch_ref(&self, patch: usize) -> PatchRef<'_> {
let (array, offset) = self.locate(patch);
self.patches.patch_ref(array, offset)
}
pub(crate) fn for_each_end_cap_entry(
&self,
range: LocalPointRange,
count: usize,
f: impl FnMut(usize, Index, f32),
) {
self.patches.local_points.for_each_entry(range, count, f);
}
pub fn patch_type(&self, patch: usize) -> PatchType {
self.locate(patch).0.kind.patch_type()
}
pub fn patch_param(&self, patch: usize) -> PatchParam {
self.params[patch].unpack()
}
pub fn patch_face(&self, patch: usize) -> Index {
self.faces[patch]
}
pub fn patch_vertices(&self, patch: usize) -> Vec<Index> {
self.patches.vertices(self.patch_ref(patch))
}
pub fn single_crease_sharpness(&self, patch: usize) -> f32 {
match self.patch_ref(patch) {
PatchRef::SingleCrease { sharpness, .. } => sharpness,
_ => 0.0,
}
}
pub fn ptex_indices(&self) -> &PtexIndices {
&self.ptex
}
pub fn num_control_values(&self) -> usize {
self.num_control_values
}
pub fn evaluate_basis(&self, patch: usize, u: f32, v: f32) -> PatchBasis {
let param = self.patch_param(patch);
self.patches
.evaluate_basis(self.patch_ref(patch), ¶m, u, v)
}
pub fn evaluate<T: Primvar>(
&self,
patch: usize,
u: f32,
v: f32,
control_values: &[T],
) -> (T, T, T) {
combine(&self.evaluate_basis(patch, u, v), control_values)
}
pub fn num_fvar_channels(&self) -> usize {
self.fvar.len()
}
fn fvar(&self, channel: usize) -> &FVarPatches {
assert!(
channel < self.fvar.len(),
"face-varying channel {channel} out of range ({} channels in the table)",
self.fvar.len()
);
&self.fvar[channel]
}
fn fvar_patch_ref(&self, patch: usize, channel: usize) -> PatchRef<'_> {
self.locate(patch); self.fvar(channel).patch_ref(patch)
}
pub fn fvar_refiner_channel(&self, channel: usize) -> usize {
self.fvar(channel).channel
}
pub fn fvar_channel_linear_interpolation(&self, channel: usize) -> FVarLinearInterpolation {
self.fvar(channel).linear_interpolation
}
pub fn num_fvar_values(&self, channel: usize) -> usize {
self.fvar(channel).num_values
}
pub fn fvar_patch_type(&self, patch: usize, channel: usize) -> PatchType {
self.locate(patch);
self.fvar(channel).locate(patch).0.kind.patch_type()
}
pub fn fvar_patch_values(&self, patch: usize, channel: usize) -> Vec<Index> {
let fvar = self.fvar(channel);
fvar.patches.vertices(self.fvar_patch_ref(patch, channel))
}
pub fn fvar_patch_param(&self, patch: usize, channel: usize) -> PatchParam {
self.fvar(channel);
self.patch_param(patch)
}
pub fn evaluate_basis_face_varying(
&self,
patch: usize,
u: f32,
v: f32,
channel: usize,
) -> PatchBasis {
let param = self.patch_param(patch);
let fvar = self.fvar(channel);
fvar.patches
.evaluate_basis(self.fvar_patch_ref(patch, channel), ¶m, u, v)
}
pub fn evaluate_face_varying<T: Primvar>(
&self,
patch: usize,
u: f32,
v: f32,
values: &[T],
channel: usize,
) -> (T, T, T) {
combine(
&self.evaluate_basis_face_varying(patch, u, v, channel),
values,
)
}
}
fn combine<T: Primvar>(basis: &PatchBasis, values: &[T]) -> (T, T, T) {
let mut point = values[0].clone();
let mut du = values[0].clone();
let mut dv = values[0].clone();
point.clear();
du.clear();
dv.clear();
for (k, &cv) in basis.indices.iter().enumerate() {
let value = &values[cv as usize];
point.add_with_weight(value, basis.weights[k]);
du.add_with_weight(value, basis.du_weights[k]);
dv.add_with_weight(value, basis.dv_weights[k]);
}
(point, du, dv)
}
pub struct PatchMap<'a> {
table: &'a PatchTable,
}
impl<'a> PatchMap<'a> {
pub fn new(table: &'a PatchTable) -> Self {
Self { table }
}
pub fn find_patch(&self, ptex_face: usize, u: f32, v: f32) -> Option<usize> {
let table = self.table;
let base_face = table.ptex.base_face(ptex_face) as usize;
let base_is_regular = table.ptex.face_ptex_count(base_face) == 1;
let (mut face, mut level, mut u, mut v) = if base_is_regular {
(base_face, 0usize, u, v)
} else {
let first_child = table.first_child.first().map(|fc| fc[base_face]);
match first_child {
Some(first_child) if first_child != INDEX_INVALID => {
let child = first_child as usize + table.ptex.base_face_corner(ptex_face);
(child, 1usize, u, v)
}
_ => return None,
}
};
loop {
match table.face_to_patch[level][face] {
INDEX_INVALID => {}
p => return Some(p as usize),
}
if level >= table.max_level {
return None;
}
let first_child = table.first_child[level][face];
if first_child == INDEX_INVALID {
return None; }
let (k, nu, nv) = if table.triangular {
descend_triangle(u, v)
} else {
descend_quadrant(u, v)
};
face = first_child as usize + k;
u = nu;
v = nv;
level += 1;
}
}
}
#[derive(Debug, Clone)]
pub struct PatchTableOptions {
pub generate_fvar_tables: bool,
pub fvar_channels: Option<Vec<usize>>,
pub generate_fvar_legacy_linear_patches: bool,
}
impl Default for PatchTableOptions {
fn default() -> Self {
Self {
generate_fvar_tables: false,
fvar_channels: None,
generate_fvar_legacy_linear_patches: true,
}
}
}
impl PatchTableOptions {
pub fn new() -> Self {
Self::default()
}
pub fn with_fvar_tables(mut self, enabled: bool) -> Self {
self.generate_fvar_tables = enabled;
self
}
pub fn with_fvar_channels(mut self, channels: &[usize]) -> Self {
self.fvar_channels = Some(channels.to_vec());
self
}
pub fn with_fvar_legacy_linear_patches(mut self, enabled: bool) -> Self {
self.generate_fvar_legacy_linear_patches = enabled;
self
}
}
pub struct PatchTableFactory;
impl PatchTableFactory {
pub fn create(refiner: &TopologyRefiner) -> Result<PatchTable, TopologyError> {
Self::create_with_options(refiner, &PatchTableOptions::default())
}
pub fn create_with_options(
refiner: &TopologyRefiner,
options: &PatchTableOptions,
) -> Result<PatchTable, TopologyError> {
Self::create_impl(refiner, options, None)
}
pub fn create_with_options_selected(
refiner: &TopologyRefiner,
options: &PatchTableOptions,
selected_faces: &[Index],
) -> Result<PatchTable, TopologyError> {
let num_faces = refiner.level(0).num_faces();
let mut selected = vec![false; num_faces];
for &face in selected_faces {
*selected
.get_mut(face as usize)
.ok_or(TopologyError::SelectedFaceOutOfRange { face, num_faces })? = true;
}
Self::create_impl(refiner, options, Some(selected))
}
fn create_impl(
refiner: &TopologyRefiner,
options: &PatchTableOptions,
selected: Option<Vec<bool>>,
) -> Result<PatchTable, TopologyError> {
let num_channels = refiner.num_fvar_channels();
let fvar_channels: Vec<usize> = match (&options.fvar_channels, options.generate_fvar_tables)
{
(_, false) => Vec::new(),
(None, true) => (0..num_channels).collect(),
(Some(channels), true) => {
if let Some(&channel) = channels.iter().find(|&&c| c >= num_channels) {
return Err(TopologyError::FVarChannelOutOfRange {
channel,
num_channels,
});
}
channels.clone()
}
};
let scheme_type = refiner.scheme_type();
let triangular = scheme_type.topological_split_type() == Split::ToTris;
let regular_size = scheme_type.regular_face_size();
let max_level = refiner.max_level();
let mut first_child: Vec<Vec<Index>> = Vec::with_capacity(max_level);
for l in 1..=max_level {
let refinement = refiner.refinement(l);
let mut fc = vec![INDEX_INVALID; refiner.level(l - 1).num_faces()];
for cf in 0..refiner.level(l).num_faces() {
let parent = refinement.child_face_parent_face(cf) as usize;
if fc[parent] == INDEX_INVALID {
fc[parent] = cf as Index;
}
}
first_child.push(fc);
}
let mut level_offsets = Vec::with_capacity(max_level + 1);
let mut total = 0usize;
for l in 0..=max_level {
level_offsets.push(total as Index);
total += refiner.level(l).num_vertices();
}
let ptex = PtexIndices::new(refiner);
let single_crease = refiner.uses_single_crease_patch();
let mut builder = PatchArraysBuilder::default();
let mut params: [Vec<PackedPatchParam>; 7] = Default::default();
let mut faces: [Vec<Index>; 7] = Default::default();
let mut levels: [Vec<u8>; 7] = Default::default();
let mut face_to_patch: Vec<Vec<Index>> = (0..=max_level)
.map(|l| vec![INDEX_INVALID; refiner.level(l).num_faces()])
.collect();
let mut face_kind: Vec<Vec<u8>> = (0..=max_level)
.map(|l| vec![0; refiner.level(l).num_faces()])
.collect();
let mut covered = selected;
for level in 0..=max_level {
let level_view = refiner.level(level);
let inner = level_view.inner();
let offset = level_offsets[level];
if level > 0 {
covered = covered.map(|parent_covered| {
let refinement = refiner.refinement(level);
(0..level_view.num_faces())
.map(|f| parent_covered[refinement.child_face_parent_face(f) as usize])
.collect()
});
}
for (face, (patch_slot, kind_slot)) in face_to_patch[level]
.iter_mut()
.zip(face_kind[level].iter_mut())
.enumerate()
{
if covered.as_ref().is_some_and(|covered| !covered[face]) {
continue;
}
if level_view.is_face_hole(face) || !refiner.face_is_candidate(level, face) {
continue;
}
if level < max_level && refiner.face_is_selected(level, face) {
continue; }
if level == 0 && level_view.face_vertices(face).len() != regular_size {
return Err(TopologyError::PatchesRequireRefinement);
}
let param =
compute_patch_param(refiner, &ptex, &first_child, face, level, triangular);
let packed =
PackedPatchParam::pack(¶m).ok_or(TopologyError::PatchDepthTooDeep {
depth: param.depth as usize,
max: PatchParam::MAX_DEPTH as usize,
})?;
debug_assert!(same_param(&packed.unpack(), ¶m));
let source = classify_patch(inner, face, scheme_type, false, single_crease);
let (kind, index) = builder.push(source, |cv| cv + offset);
*patch_slot = index as Index;
*kind_slot = kind as u8;
params[kind as usize].push(packed);
faces[kind as usize].push(face as Index);
levels[kind as usize].push(level as u8);
}
}
let (patches, starts) = builder.finish();
let params: Vec<PackedPatchParam> = flatten(params);
let faces: Vec<Index> = flatten(faces);
let levels: Vec<u8> = flatten(levels);
for (patches, kinds) in face_to_patch.iter_mut().zip(&face_kind) {
for (patch, &kind) in patches.iter_mut().zip(kinds) {
if *patch != INDEX_INVALID {
*patch += starts[kind as usize] as Index;
}
}
}
let fvar = fvar_channels
.into_iter()
.map(|channel| {
build_fvar_patches(
refiner,
channel,
options.generate_fvar_legacy_linear_patches,
&levels,
&faces,
)
})
.collect();
Ok(PatchTable {
patches,
params,
faces,
face_to_patch,
ptex,
max_level,
first_child,
num_control_values: total,
triangular,
fvar,
})
}
}
fn flatten<T>(arrays: [Vec<T>; 7]) -> Vec<T> {
let mut flat = Vec::with_capacity(arrays.iter().map(Vec::len).sum());
arrays.into_iter().for_each(|array| flat.extend(array));
flat
}
fn build_fvar_patches(
refiner: &TopologyRefiner,
channel: usize,
legacy_linear: bool,
levels: &[u8],
faces: &[Index],
) -> FVarPatches {
let fvar = refiner.fvar_channel(channel);
let scheme_type = refiner.scheme_type();
let linear = legacy_linear || fvar.is_linear();
let single_crease = refiner.uses_single_crease_patch();
let mut level_offsets = Vec::with_capacity(refiner.num_levels());
let mut num_values = 0usize;
for l in 0..refiner.num_levels() {
level_offsets.push(num_values as Index);
num_values += fvar.num_values(l);
}
let base_sources = fvar.base_value_sources();
let mut builder = PatchArraysBuilder::default();
let mut kinds = Vec::with_capacity(faces.len());
let mut offsets = Vec::with_capacity(faces.len());
for (&level, &face) in levels.iter().zip(faces) {
let level = level as usize;
let source = classify_patch(
fvar.level(level),
face as usize,
scheme_type,
linear,
single_crease,
);
let (kind, offset) = match (level, base_sources) {
(0, Some(sources)) => builder.push(source, |value| sources[value as usize]),
_ => {
let first = level_offsets[level];
builder.push(source, |value| value + first)
}
};
kinds.push(kind);
offsets.push(offset as u32);
}
let (patches, _) = builder.finish();
let (arrays, offsets) = if patches.arrays.len() <= 1 {
(Vec::new(), Vec::new())
} else {
let array_of = |kind: ArrayKind| {
let index = patches.arrays.iter().position(|a| a.kind == kind);
index.expect("every patch kind used has an array") as u8
};
(kinds.into_iter().map(array_of).collect(), offsets)
};
FVarPatches {
channel,
linear_interpolation: fvar.linear_interpolation(),
num_values,
patches,
arrays,
offsets,
}
}
enum PatchSource {
Cvs(ArrayKind, [Index; 16]),
SingleCrease(SingleCrease),
Gregory(gregory::GregoryPoints),
GregoryTriangle(loop_patch::GregoryTriPoints),
}
fn classify_patch(
level: &Level,
face: usize,
scheme_type: SchemeType,
linear: bool,
single_crease: bool,
) -> PatchSource {
let linear_patch = || {
let fv = level.face_vertices(face);
let mut cvs = [INDEX_INVALID; 16];
cvs[..fv.len()].copy_from_slice(fv);
let kind = if fv.len() == 3 {
ArrayKind::Triangles
} else {
ArrayKind::Quads
};
debug_assert_eq!(fv.len(), kind.num_cvs());
PatchSource::Cvs(kind, cvs)
};
if linear {
return linear_patch();
}
match scheme_type {
SchemeType::Catmark => {
if let Some(cvs) = gather_regular_patch(level, face) {
PatchSource::Cvs(ArrayKind::Regular, cvs)
} else if let Some(patch) = single_crease
.then(|| single_crease_patch(level, face))
.flatten()
{
PatchSource::SingleCrease(patch)
} else if let Some(points) = gregory::build(level, face) {
PatchSource::Gregory(points)
} else {
linear_patch()
}
}
SchemeType::Loop => {
if let Some(loop_cvs) = loop_patch::gather_regular_patch(level, face) {
let mut cvs = [INDEX_INVALID; 16];
cvs[..12].copy_from_slice(&loop_cvs);
PatchSource::Cvs(ArrayKind::Loop, cvs)
} else if let Some(points) = loop_patch::build(level, face) {
PatchSource::GregoryTriangle(points)
} else {
linear_patch()
}
}
SchemeType::Bilinear => linear_patch(),
}
}
#[derive(Default)]
struct ArrayBuilder {
len: usize,
cvs: Vec<Index>,
creases: Vec<(f32, u8)>,
end_caps: Vec<LocalPointRange>,
}
#[derive(Default)]
struct PatchArraysBuilder {
arrays: [ArrayBuilder; 7],
local_points: LocalPoints,
}
impl PatchArraysBuilder {
fn push(&mut self, source: PatchSource, map: impl Fn(Index) -> Index) -> (ArrayKind, usize) {
let shift = |cv: Index| {
if cv == INDEX_INVALID {
cv
} else {
map(cv)
}
};
let kind = match source {
PatchSource::Cvs(kind, cvs) => {
let array = &mut self.arrays[kind as usize];
array
.cvs
.extend(cvs[..kind.num_cvs()].iter().map(|&cv| shift(cv)));
kind
}
PatchSource::SingleCrease(patch) => {
let array = &mut self.arrays[ArrayKind::SingleCrease as usize];
array.cvs.extend(patch.cvs.iter().map(|&cv| shift(cv)));
array.creases.push((patch.sharpness, patch.edge));
ArrayKind::SingleCrease
}
PatchSource::Gregory(points) => {
let range = self.local_points.push(&points, &map);
self.arrays[ArrayKind::Gregory as usize]
.end_caps
.push(range);
ArrayKind::Gregory
}
PatchSource::GregoryTriangle(points) => {
let range = self.local_points.push(&points, &map);
self.arrays[ArrayKind::GregoryTriangle as usize]
.end_caps
.push(range);
ArrayKind::GregoryTriangle
}
};
let array = &mut self.arrays[kind as usize];
array.len += 1;
(kind, array.len - 1)
}
fn finish(self) -> (PatchArrays, [usize; 7]) {
let Self {
arrays: builders,
mut local_points,
} = self;
let total_of = |f: fn(&ArrayBuilder) -> usize| builders.iter().map(f).sum::<usize>();
let mut arrays = Vec::new();
let mut cvs = Vec::with_capacity(total_of(|b| b.cvs.len()));
let mut creases = Vec::with_capacity(total_of(|b| b.creases.len()));
let mut end_caps = Vec::with_capacity(total_of(|b| b.end_caps.len()));
let mut starts = [0usize; 7];
let mut start = 0;
for (kind, builder) in ArrayKind::ALL.into_iter().zip(builders) {
starts[kind as usize] = start;
if builder.len == 0 {
continue;
}
arrays.push(PatchArray {
kind,
start,
first_cv: cvs.len(),
first_aux: match kind {
ArrayKind::SingleCrease => creases.len(),
ArrayKind::Gregory | ArrayKind::GregoryTriangle => end_caps.len(),
_ => 0,
},
});
start += builder.len;
cvs.extend(builder.cvs);
creases.extend(builder.creases);
end_caps.extend(builder.end_caps);
}
local_points.shrink_to_fit();
let patches = PatchArrays {
arrays,
cvs,
creases,
end_caps,
local_points,
};
(patches, starts)
}
}
fn same_param(a: &PatchParam, b: &PatchParam) -> bool {
a.ptex_face == b.ptex_face
&& a.depth == b.depth
&& a.rotation == b.rotation
&& a.triangular == b.triangular
&& a.origin.map(f32::to_bits) == b.origin.map(f32::to_bits)
}
const CORNER_UV: [[f32; 2]; 4] = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]];
fn rotate_ccw(times: u32, x: f32, y: f32) -> (f32, f32) {
match times % 4 {
0 => (x, y),
1 => (-y, x),
2 => (-x, -y),
_ => (y, -x),
}
}
fn descend_quadrant(u: f32, v: f32) -> (usize, f32, f32) {
let k = match (u < 0.5, v < 0.5) {
(true, true) => 0,
(false, true) => 1,
(false, false) => 2,
(true, false) => 3,
};
let (x, y) = (u - CORNER_UV[k][0], v - CORNER_UV[k][1]);
let (x, y) = rotate_ccw((4 - k as u32) % 4, x, y);
(k, x * 2.0, y * 2.0)
}
const TRI_CHILD_ORIGIN: [[f32; 2]; 4] = [[0.0, 0.0], [0.5, 0.0], [0.0, 0.5], [0.5, 0.5]];
const TRI_CHILD_ROTATION: [usize; 4] = [0, 0, 0, 2];
fn descend_triangle(u: f32, v: f32) -> (usize, f32, f32) {
let k = if u >= 0.5 {
1
} else if v >= 0.5 {
2
} else if u + v >= 0.5 {
3
} else {
0
};
let (x, y) = (u - TRI_CHILD_ORIGIN[k][0], v - TRI_CHILD_ORIGIN[k][1]);
let (x, y) = rotate_ccw((4 - TRI_CHILD_ROTATION[k] as u32) % 4, x, y);
(k, x * 2.0, y * 2.0)
}
fn compute_patch_param(
refiner: &TopologyRefiner,
ptex: &PtexIndices,
first_child: &[Vec<Index>],
face: usize,
level: usize,
triangular: bool,
) -> PatchParam {
let mut origin = [0.0f32; 2];
let mut rotation = 0u8;
let mut depth = 0u8;
let mut face = face;
let compose = |origin: &mut [f32; 2], rotation: &mut u8, depth: &mut u8, k: usize| {
let (child_origin, child_rotation) = if triangular {
(TRI_CHILD_ORIGIN[k], TRI_CHILD_ROTATION[k])
} else {
(CORNER_UV[k], k)
};
let (x, y) = rotate_ccw(child_rotation as u32, origin[0], origin[1]);
origin[0] = child_origin[0] + 0.5 * x;
origin[1] = child_origin[1] + 0.5 * y;
*rotation = ((*rotation as usize + child_rotation) % 4) as u8;
*depth += 1;
};
for l in (2..=level).rev() {
let parent = refiner.refinement(l).child_face_parent_face(face) as usize;
let k = face - first_child[l - 1][parent] as usize;
compose(&mut origin, &mut rotation, &mut depth, k);
face = parent;
}
if level == 0 {
return PatchParam {
ptex_face: ptex.face_id(face),
depth: 0,
rotation: 0,
origin: [0.0, 0.0],
triangular,
};
}
let base = refiner.refinement(1).child_face_parent_face(face) as usize;
let k = face - first_child[0][base] as usize;
if ptex.face_ptex_count(base) == 1 {
compose(&mut origin, &mut rotation, &mut depth, k);
PatchParam {
ptex_face: ptex.face_id(base),
depth,
rotation,
origin,
triangular,
}
} else {
PatchParam {
ptex_face: ptex.face_id(base) + k as Index,
depth,
rotation,
origin,
triangular,
}
}
}
fn is_corner_regular(level: &Level, face: usize, corner: usize) -> bool {
let v = level.face_vertices(face)[corner] as usize;
let edges = level.vertex_edges(v);
let num_faces = level.vertex_faces(v).len();
let vertex_sharpness = level.vertex_sharpness(v);
if Crease::is_semi_sharp(vertex_sharpness)
|| edges
.iter()
.any(|&e| Crease::is_semi_sharp(level.edge_sharpness(e as usize)))
{
return false;
}
let inf_edges = edges
.iter()
.filter(|&&e| Crease::is_infinite(level.edge_sharpness(e as usize)))
.count();
let boundary = level.is_vertex_boundary(v);
let span_faces = || corner_span(level, face, corner, true).map(|span| span.num_faces());
match vertex_rule(vertex_sharpness, inf_edges) {
Rule::Smooth => !boundary && edges.len() == 4 && num_faces == 4,
Rule::Dart => false,
Rule::Crease => {
if boundary {
num_faces == 2 && edges.len() == 3
} else {
span_faces() == Some(2)
}
}
Rule::Corner => inf_edges > 0 && span_faces() == Some(1),
Rule::Unknown => false,
}
}
fn cross_edge(level: &Level, edge: Index, face: Index) -> Option<Index> {
if is_edge_singular(level, edge, true) {
return None;
}
let faces = level.edge_faces(edge as usize);
Some(if faces[0] == face { faces[1] } else { faces[0] })
}
fn neighbor_in_face(level: &Level, face: Index, v: Index, exclude: Index) -> Option<Index> {
let fv = level.face_vertices(face as usize);
if fv.len() != 4 {
return None;
}
let i = fv.iter().position(|&x| x == v)?;
let n = fv.len();
let prev = fv[(i + n - 1) % n];
let next = fv[(i + 1) % n];
if prev == exclude {
Some(next)
} else if next == exclude {
Some(prev)
} else {
None
}
}
fn diagonal_in_face(level: &Level, face: Index, v: Index) -> Option<Index> {
let fv = level.face_vertices(face as usize);
if fv.len() != 4 {
return None;
}
let i = fv.iter().position(|&x| x == v)?;
Some(fv[(i + 2) % 4])
}
pub(super) fn gather_regular_patch(level: &Level, face: usize) -> Option<[Index; 16]> {
let fv = level.face_vertices(face);
if fv.len() != 4 {
return None;
}
for corner in 0..4 {
if !is_corner_regular(level, face, corner) {
return None;
}
}
gather_grid(level, face)
}
fn gather_grid(level: &Level, face: usize) -> Option<[Index; 16]> {
let fv = level.face_vertices(face);
let [c0, c1, c2, c3] = [fv[0], fv[1], fv[2], fv[3]];
let fe = level.face_edges(face);
let face = face as Index;
let mut cvs = [INDEX_INVALID; 16];
cvs[5] = c0;
cvs[6] = c1;
cvs[10] = c2;
cvs[9] = c3;
let a0 = cross_edge(level, fe[0], face); let a1 = cross_edge(level, fe[1], face); let a2 = cross_edge(level, fe[2], face); let a3 = cross_edge(level, fe[3], face);
if let Some(a) = a0 {
cvs[1] = neighbor_in_face(level, a, c0, c1)?;
cvs[2] = neighbor_in_face(level, a, c1, c0)?;
}
if let Some(a) = a1 {
cvs[7] = neighbor_in_face(level, a, c1, c2)?;
cvs[11] = neighbor_in_face(level, a, c2, c1)?;
}
if let Some(a) = a2 {
cvs[14] = neighbor_in_face(level, a, c2, c3)?;
cvs[13] = neighbor_in_face(level, a, c3, c2)?;
}
if let Some(a) = a3 {
cvs[4] = neighbor_in_face(level, a, c0, c3)?;
cvs[8] = neighbor_in_face(level, a, c3, c0)?;
}
cvs[0] = gather_corner_cv(level, a0, c0, cvs[1])?; cvs[3] = gather_corner_cv(level, a0, c1, cvs[2])?;
cvs[15] = gather_corner_cv(level, a1, c2, cvs[11])?;
cvs[12] = gather_corner_cv(level, a3, c3, cvs[8])?;
let row0 = a0.is_none();
let col3 = a1.is_none();
let row3 = a2.is_none();
let col0 = a3.is_none();
for j in 0..4 {
for i in 0..4 {
let phantom_expected =
(j == 0 && row0) || (j == 3 && row3) || (i == 0 && col0) || (i == 3 && col3);
let is_phantom = cvs[4 * j + i] == INDEX_INVALID;
if (1..3).contains(&i) && (1..3).contains(&j) {
debug_assert!(!is_phantom);
}
if phantom_expected != is_phantom {
return None;
}
}
}
Some(cvs)
}
fn gather_corner_cv(level: &Level, a: Option<Index>, c: Index, inner: Index) -> Option<Index> {
if let Some(a) = a {
if inner != INDEX_INVALID {
if let Some(edge) = level.find_edge(c, inner) {
if let Some(d) = cross_edge(level, edge, a) {
return diagonal_in_face(level, d, c);
}
}
}
}
Some(INDEX_INVALID)
}
#[derive(Debug, Clone, Copy)]
pub(super) struct SingleCrease {
pub(super) cvs: [Index; 16],
pub(super) edge: u8,
pub(super) sharpness: f32,
}
pub(super) fn single_crease_patch(level: &Level, face: usize) -> Option<SingleCrease> {
let fv = level.face_vertices(face);
if fv.len() != 4 {
return None;
}
for &v in fv {
let v = v as usize;
if level.is_vertex_boundary(v)
|| level.vertex_edges(v).len() != 4
|| level.vertex_faces(v).len() != 4
|| Crease::is_sharp(level.vertex_sharpness(v))
{
return None;
}
}
let fe = level.face_edges(face);
let mut crease = None;
for (k, &e) in fe.iter().enumerate() {
let sharpness = level.edge_sharpness(e as usize);
if Crease::is_semi_sharp(sharpness) {
if crease.is_some() {
return None;
}
crease = Some((k, sharpness));
} else if Crease::is_sharp(sharpness) {
return None;
}
}
let (k, sharpness) = crease?;
let crease_edge = fe[k] as usize;
for (corner, &v) in fv.iter().enumerate() {
let on_crease = corner == k || corner == (k + 1) % 4;
let mut sharp = level
.vertex_edges(v as usize)
.iter()
.map(|&e| e as usize)
.filter(|&e| Crease::is_sharp(level.edge_sharpness(e)));
if !on_crease {
if sharp.next().is_some() {
return None;
}
continue;
}
let others: Vec<usize> = sharp.filter(|&e| e != crease_edge).collect();
let [other] = others[..] else {
return None;
};
let crease_faces = level.edge_faces(crease_edge);
if level.edge_sharpness(other) != sharpness
|| level
.edge_faces(other)
.iter()
.any(|f| crease_faces.contains(f))
{
return None;
}
}
let cvs = gather_grid(level, face)?;
if cvs.contains(&INDEX_INVALID) {
return None;
}
Some(SingleCrease {
cvs,
edge: k as u8,
sharpness,
})
}
fn fold_phantom_weights(cvs: &[Index; 16], weights: &mut [f32]) {
let row0 = cvs[1] == INDEX_INVALID;
let row3 = cvs[13] == INDEX_INVALID;
let col0 = cvs[4] == INDEX_INVALID;
let col3 = cvs[7] == INDEX_INVALID;
for _ in 0..2 {
for j in 0..4usize {
for i in 0..4usize {
let slot = 4 * j + i;
if cvs[slot] != INDEX_INVALID || weights[slot] == 0.0 {
continue;
}
let (a, b) = if j == 0 && row0 {
(4 + i, 8 + i) } else if j == 3 && row3 {
(8 + i, 4 + i)
} else if i == 0 && col0 {
(4 * j + 1, 4 * j + 2) } else {
debug_assert!(i == 3 && col3);
(4 * j + 2, 4 * j + 1)
};
let w = weights[slot];
weights[a] += 2.0 * w;
weights[b] -= w;
weights[slot] = 0.0;
}
}
}
}
pub(crate) fn bspline_basis(t: f32) -> ([f32; 4], [f32; 4]) {
let (b, d) = bspline_basis_f64(f64::from(t));
(b.map(|x| x as f32), d.map(|x| x as f32))
}
fn crease_basis(t: f32, sharpness: f32) -> ([f32; 4], [f32; 4]) {
let n = sharpness.floor();
let f = f64::from(sharpness - n);
let t = f64::from(t);
let (mut w, mut d) = integer_crease_basis(t, n as u32);
if f > 0.0 {
let (w1, d1) = integer_crease_basis(t, n as u32 + 1);
for k in 0..4 {
w[k] = (1.0 - f) * w[k] + f * w1[k];
d[k] = (1.0 - f) * d[k] + f * d1[k];
}
}
(w.map(|x| x as f32), d.map(|x| x as f32))
}
fn integer_crease_basis(t: f64, n: u32) -> ([f64; 4], [f64; 4]) {
let (b, db) = bspline_basis_f64(t);
if n == 0 {
return (b, db);
}
let fold = |x: [f64; 4]| [0.0, x[1] + 2.0 * x[0], x[2] - x[0], x[3]];
let h = 0.5f64.powi(n as i32);
if t >= h {
return (fold(b), fold(db));
}
let mut window = [
[0.0, 2.0, -1.0, 0.0],
[0.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0],
];
let mix = |a: &[f64; 4], wa: f64, b: &[f64; 4], wb: f64, c: &[f64; 4], wc: f64| {
[0, 1, 2, 3].map(|k| wa * a[k] + wb * b[k] + wc * c[k])
};
for _ in 0..n {
let [q0, q1, q2, q3] = window;
window = [
mix(&q0, 0.5, &q1, 0.5, &q2, 0.0),
mix(&q0, 0.125, &q1, 0.75, &q2, 0.125),
mix(&q1, 0.5, &q2, 0.5, &q3, 0.0),
mix(&q1, 0.125, &q2, 0.75, &q3, 0.125),
];
}
window[0] = [h, 1.0 - h, 0.0, 0.0];
let (b, db) = bspline_basis_f64(t / h);
let mut w = [0.0; 4];
let mut d = [0.0; 4];
for (point, weights) in window.iter().enumerate() {
for k in 0..4 {
w[k] += b[point] * weights[k];
d[k] += db[point] / h * weights[k];
}
}
(w, d)
}
fn bspline_basis_f64(t: f64) -> ([f64; 4], [f64; 4]) {
let t2 = t * t;
let t3 = t2 * t;
let one_minus = 1.0 - t;
let basis = [
one_minus * one_minus * one_minus / 6.0,
(3.0 * t3 - 6.0 * t2 + 4.0) / 6.0,
(-3.0 * t3 + 3.0 * t2 + 3.0 * t + 1.0) / 6.0,
t3 / 6.0,
];
let deriv = [
-0.5 * one_minus * one_minus,
1.5 * t2 - 2.0 * t,
-1.5 * t2 + t + 0.5,
0.5 * t2,
];
(basis, deriv)
}
pub(crate) fn crease_basis_oriented(
x: f32,
sharpness: f32,
reversed: bool,
) -> ([f32; 4], [f32; 4]) {
if !reversed {
return crease_basis(x, sharpness);
}
let (w, d) = crease_basis(1.0 - x, sharpness);
([w[3], w[2], w[1], w[0]], [-d[3], -d[2], -d[1], -d[0]])
}
#[cfg(test)]
mod tests {
use super::*;
use crate::far::{AdaptiveOptions, TopologyDescriptor, TopologyRefinerFactory};
use crate::sdc;
fn param(depth: u8, rotation: u8, cell: [u32; 2], triangular: bool) -> PatchParam {
let scale = (1u32 << depth) as f32;
let corner = CORNER_UV[rotation as usize];
PatchParam {
ptex_face: 0xdead_beef,
depth,
rotation,
origin: [0, 1].map(|k| (cell[k] as f32 + corner[k]) / scale),
triangular,
}
}
#[test]
fn packed_params_round_trip_up_to_max_depth() {
for depth in 0..=PatchParam::MAX_DEPTH {
let last = (1u32 << depth) - 1;
for rotation in 0..4 {
for cell in [
[0, 0],
[last, 0],
[0, last],
[last, last],
[last / 3, last / 2],
] {
for triangular in [false, true] {
let p = param(depth, rotation, cell, triangular);
let packed = PackedPatchParam::pack(&p).unwrap();
assert!(same_param(&packed.unpack(), &p), "{p:?}");
}
}
}
}
let too_deep = param(PatchParam::MAX_DEPTH + 1, 0, [0, 0], false);
assert!(PackedPatchParam::pack(&too_deep).is_none());
}
#[test]
fn tables_store_every_orientation_exactly() {
let mut pentagon = (vec![5], vec![0, 1, 2, 3, 4]);
for i in 0..5u32 {
let j = (i + 1) % 5;
pentagon.0.push(4);
pentagon.1.extend([j, i, i + 5, j + 5]);
}
let mut tris = (Vec::new(), Vec::new());
for j in 0..3u32 {
for i in 0..3u32 {
let v = j * 4 + i;
tris.0.extend([3, 3]);
tris.1.extend([v, v + 1, v + 5, v, v + 5, v + 4]);
}
}
let options = sdc::Options::default()
.with_vtx_boundary_interpolation(sdc::VtxBoundaryInterpolation::EdgeAndCorner);
let mut seen = Vec::new();
for (num_verts, mesh, scheme) in [
(10, &pentagon, sdc::SchemeType::Catmark),
(16, &tris, sdc::SchemeType::Loop),
] {
let descriptor = TopologyDescriptor::new(num_verts, &mesh.0, &mesh.1);
let mut refiner = TopologyRefinerFactory::create(descriptor, scheme, options).unwrap();
refiner.refine_adaptive(AdaptiveOptions::new(3));
let table = PatchTableFactory::create(&refiner).unwrap();
for p in 0..table.num_patches() {
let param = table.patch_param(p);
seen.push((param.triangular, param.rotation));
}
}
for expected in [
(false, 0),
(false, 1),
(false, 2),
(false, 3),
(true, 0),
(true, 2),
] {
assert!(seen.contains(&expected), "no patch at {expected:?}");
}
}
}