use crate::sdc::{self, Crease, FVarLinearInterpolation, Scheme, SchemeType};
use crate::vtr::{Level, Refinement, TopologyError};
use crate::Index;
use std::borrow::Cow;
#[derive(Debug, Clone)]
pub struct FVarChannel {
linear_interpolation: FVarLinearInterpolation,
scheme: Scheme,
linear: bool,
num_base_values: usize,
base_face_values: Vec<Index>,
base_value_sources: Option<Vec<Index>>,
levels: Vec<Level>,
refinements: Vec<Refinement>,
}
impl FVarChannel {
pub(super) fn create(
geometry: &Level,
scheme_type: SchemeType,
options: sdc::Options,
channel_index: usize,
num_values: usize,
value_indices: &[Index],
) -> Result<FVarChannel, TopologyError> {
if value_indices.len() != geometry.num_face_vertices_total() {
return Err(TopologyError::FVarValueCountMismatch {
channel: channel_index,
expected: geometry.num_face_vertices_total(),
actual: value_indices.len(),
});
}
for &v in value_indices {
if v as usize >= num_values {
return Err(TopologyError::FVarValueIndexOutOfRange {
channel: channel_index,
index: v,
});
}
}
let mode = options.fvar_linear_interpolation;
let linear = mode == FVarLinearInterpolation::All;
let scheme = Scheme::new(scheme_type, channel_options(options));
let verts_per_face: Vec<usize> = (0..geometry.num_faces())
.map(|f| geometry.face_vertices(f).len())
.collect();
let (split_indices, base_value_sources) =
split_reused_values(geometry, num_values, value_indices);
let num_split_values = base_value_sources.as_ref().map_or(num_values, Vec::len);
let mut value_mesh =
Level::from_face_vertices(num_split_values, &verts_per_face, &split_indices)?;
if !linear {
for f in 0..geometry.num_faces() {
let geom_edges = geometry.face_edges(f);
let geom_verts = geometry.face_vertices(f);
let fvar_edges = value_mesh.face_edges(f).to_vec();
let fvar_values = value_mesh.face_vertices(f).to_vec();
for i in 0..geom_verts.len() {
let ge = geom_edges[i] as usize;
let fe = fvar_edges[i] as usize;
let es = geometry
.edge_sharpness(ge)
.max(value_mesh.edge_sharpness(fe));
value_mesh.set_edge_sharpness(fe, es);
let gv = geom_verts[i] as usize;
let fv = fvar_values[i] as usize;
let vs = geometry
.vertex_sharpness(gv)
.max(value_mesh.vertex_sharpness(fv));
value_mesh.set_vertex_sharpness(fv, vs);
}
}
value_mesh.sharpen_boundaries(scheme.crease());
apply_mode_sharpening(mode, geometry, &mut value_mesh);
}
Ok(FVarChannel {
linear_interpolation: mode,
scheme,
linear,
num_base_values: num_values,
base_face_values: value_indices.to_vec(),
base_value_sources,
levels: vec![value_mesh],
refinements: Vec::new(),
})
}
pub(super) fn refine_once(&mut self, included: Option<&[bool]>) {
let parent = self.levels.last().unwrap();
let (mut child, refinement) = match included {
Some(included) => Refinement::refine_included(parent, &self.scheme, included),
None => Refinement::refine(parent, &self.scheme),
}
.expect("refined face-varying topology is always internally consistent");
if self.linear_interpolation == FVarLinearInterpolation::Boundaries {
pin_boundary_values(&mut child);
}
self.levels.push(child);
self.refinements.push(refinement);
}
pub fn linear_interpolation(&self) -> FVarLinearInterpolation {
self.linear_interpolation
}
pub(super) fn scheme(&self) -> &Scheme {
&self.scheme
}
pub(super) fn is_linear(&self) -> bool {
self.linear
}
pub(super) fn level(&self, level: usize) -> &Level {
&self.levels[level]
}
pub(super) fn num_values(&self, level: usize) -> usize {
if level == 0 {
self.num_base_values
} else {
self.levels[level].num_vertices()
}
}
pub(super) fn face_values(&self, level: usize, face: usize) -> &[Index] {
if level == 0 {
let level0 = &self.levels[0];
let start = level0.face_vertices_offset(face);
&self.base_face_values[start..start + level0.face_vertices(face).len()]
} else {
self.levels[level].face_vertices(face)
}
}
pub(super) fn base_source_values<'a, T: Clone>(&self, src: &'a [T]) -> Cow<'a, [T]> {
assert!(
src.len() >= self.num_base_values,
"src buffer too small: {} values, expected at least {}",
src.len(),
self.num_base_values
);
match &self.base_value_sources {
None => Cow::Borrowed(src),
Some(sources) => Cow::Owned(sources.iter().map(|&v| src[v as usize].clone()).collect()),
}
}
pub(super) fn base_value_sources(&self) -> Option<&[Index]> {
self.base_value_sources.as_deref()
}
pub(super) fn refinement(&self, level: usize) -> &Refinement {
&self.refinements[level - 1]
}
}
fn split_reused_values(
geometry: &Level,
num_values: usize,
value_indices: &[Index],
) -> (Vec<Index>, Option<Vec<Index>>) {
let mut first_vertex: Vec<Option<Index>> = vec![None; num_values];
let mut extra_at_vertex: Vec<Vec<(Index, Index)>> = vec![Vec::new(); geometry.num_vertices()];
let mut sources: Vec<Index> = (0..num_values as Index).collect();
let mut split = Vec::with_capacity(value_indices.len());
let mut corner = 0;
for f in 0..geometry.num_faces() {
for &v in geometry.face_vertices(f) {
let val = value_indices[corner];
corner += 1;
let id = match first_vertex[val as usize] {
None => {
first_vertex[val as usize] = Some(v);
val
}
Some(first) if first == v => val,
Some(_) => {
let extra = &mut extra_at_vertex[v as usize];
match extra.iter().find(|(existing, _)| *existing == val) {
Some(&(_, id)) => id,
None => {
let id = sources.len() as Index;
sources.push(val);
extra.push((val, id));
id
}
}
}
};
split.push(id);
}
}
let sources = (sources.len() > num_values).then_some(sources);
(split, sources)
}
fn channel_options(options: sdc::Options) -> sdc::Options {
use sdc::VtxBoundaryInterpolation::{EdgeAndCorner, EdgeOnly};
let vtx = match options.fvar_linear_interpolation {
FVarLinearInterpolation::All | FVarLinearInterpolation::None => EdgeOnly,
FVarLinearInterpolation::CornersOnly
| FVarLinearInterpolation::CornersPlus1
| FVarLinearInterpolation::CornersPlus2
| FVarLinearInterpolation::Boundaries => EdgeAndCorner,
};
options.with_vtx_boundary_interpolation(vtx)
}
fn apply_mode_sharpening(mode: FVarLinearInterpolation, geometry: &Level, value_mesh: &mut Level) {
match mode {
FVarLinearInterpolation::All
| FVarLinearInterpolation::None
| FVarLinearInterpolation::CornersOnly => {}
FVarLinearInterpolation::CornersPlus1 | FVarLinearInterpolation::CornersPlus2 => {
let mut values_at_vertex: Vec<Vec<(Index, usize)>> =
vec![Vec::new(); geometry.num_vertices()];
for f in 0..geometry.num_faces() {
let gv = geometry.face_vertices(f);
let fv = value_mesh.face_vertices(f);
for (&v, &val) in gv.iter().zip(fv) {
let vals = &mut values_at_vertex[v as usize];
match vals.iter_mut().find(|(existing, _)| *existing == val) {
Some((_, span)) => *span += 1,
None => vals.push((val, 1)),
}
}
}
for (v, vals) in values_at_vertex.iter().enumerate() {
let junction = vals.len() > 2;
let dart = mode == FVarLinearInterpolation::CornersPlus2
&& vals.len() == 1
&& !geometry.is_vertex_boundary(v)
&& value_mesh.is_vertex_boundary(vals[0].0 as usize);
let concave = mode == FVarLinearInterpolation::CornersPlus2
&& vals.len() == 2
&& (vals[0].1 == 1 || vals[1].1 == 1);
if junction || dart || concave {
for &(val, _) in vals {
value_mesh.set_vertex_sharpness(val as usize, sdc::SHARPNESS_INFINITE);
}
}
}
}
FVarLinearInterpolation::Boundaries => pin_boundary_values(value_mesh),
}
}
fn pin_boundary_values(value_mesh: &mut Level) {
for v in 0..value_mesh.num_vertices() {
if value_mesh.is_vertex_boundary(v) && !Crease::is_infinite(value_mesh.vertex_sharpness(v))
{
value_mesh.set_vertex_sharpness(v, sdc::SHARPNESS_INFINITE);
}
}
}