use crate::loading::number_expr::eval_number;
use indicatrix::optics::materials::{
GemMaterial,
body_color::{BODY_COLOR_PRESETS, preset_index_for_rgb},
};
use indicatrix_cut_core::{Design, Edit, MaterialSelection, RemapRounding};
pub const GEAR_PRESETS: [i32; 6] = [96, 80, 77, 72, 64, 120];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GearRemapPreviewRow {
pub name: String,
pub old_indices: String,
pub new_indices: String,
pub non_integral: bool,
}
impl MaterialComboCache {
pub fn options(&mut self, custom: &[GemMaterial]) -> Vec<String> {
let signature: Vec<String> = custom.iter().map(|m| m.name.clone()).collect();
if self.signature.as_ref() != Some(&signature) {
self.options = design_material_options(custom);
self.signature = Some(signature);
}
self.options.clone()
}
}
#[derive(Default)]
pub struct MaterialComboCache {
signature: Option<Vec<String>>,
options: Vec<String>,
}
#[must_use]
pub fn builtin_preset_names() -> Vec<String> {
std::iter::once("(none)".to_string())
.chain(indicatrix_cut_core::MaterialCatalogue::build(&[]).names())
.collect()
}
#[cfg(test)]
#[must_use]
pub fn material_index_from_name(name: Option<&str>) -> i32 {
let names = builtin_preset_names();
name.and_then(|n| names.iter().position(|p| p == n))
.map_or(0, |i| i as i32)
}
#[must_use]
pub fn material_name_from_index(index: i32) -> Option<String> {
let names = builtin_preset_names();
usize::try_from(index)
.ok()
.and_then(|i| names.get(i).cloned())
.filter(|name| name != "(none)")
}
pub fn parse_yield_form(
girdle_diameter_mm: &str,
_material_index: i32,
specific_gravity_override: &str,
current: &MaterialSelection,
) -> Result<(Option<f64>, MaterialSelection), String> {
let girdle_diameter_mm = if girdle_diameter_mm.trim().is_empty() {
None
} else {
let value = eval_number(girdle_diameter_mm, None)
.map_err(|error| error.message("Girdle diameter", girdle_diameter_mm))?;
if !value.is_finite() || value <= 0.0 {
return Err("Girdle diameter must be a positive, finite number.".to_string());
}
Some(value)
};
let specific_gravity_override = if specific_gravity_override.trim().is_empty() {
None
} else {
let value = eval_number(specific_gravity_override, None)
.map_err(|error| error.message("Specific gravity", specific_gravity_override))?;
if !value.is_finite() || value <= 0.0 {
return Err("Specific gravity override must be a positive, finite number.".to_string());
}
Some(value)
};
Ok((
girdle_diameter_mm,
current.with_specific_gravity_override(specific_gravity_override),
))
}
#[must_use]
pub fn ri_source_text(material: &MaterialSelection, custom: &[GemMaterial]) -> String {
if let Some(value) = material.refractive_index_override {
return format!("typed override ({value:.4})");
}
if let Some(name) = material.name.as_deref() {
if custom.iter().any(|gem| gem.name.eq_ignore_ascii_case(name)) {
return format!("custom catalogue material '{name}'");
}
if indicatrix_cut_core::built_in_refractive_index(name).is_some() {
return format!("built-in material '{name}'");
}
return format!(
"'{name}' is not a recognized material -- falling back to this design's legacy imported value"
);
}
"no material selected -- using this design's legacy imported value".to_string()
}
const CUSTOM_BUILTIN_COLLISION_SUFFIX: &str = " (custom)";
#[must_use]
pub fn design_material_options(custom: &[GemMaterial]) -> Vec<String> {
let mut options: Vec<String> = builtin_preset_names();
for material in custom {
if options
.iter()
.any(|name| name.eq_ignore_ascii_case(&material.name))
{
options.push(format!(
"{}{CUSTOM_BUILTIN_COLLISION_SUFFIX}",
material.name
));
} else {
options.push(material.name.clone());
}
}
options.push("Custom RI\u{2026}".to_string());
options
}
#[must_use]
pub fn design_material_index_from_name(name: Option<&str>, options: &[String]) -> i32 {
name.and_then(|n| {
options.iter().position(|o| {
o.strip_suffix(CUSTOM_BUILTIN_COLLISION_SUFFIX)
.unwrap_or(o)
.eq_ignore_ascii_case(n)
})
})
.map_or(0, |i| i as i32)
}
#[must_use]
pub fn design_material_name_from_index(index: i32, options: &[String]) -> Option<String> {
usize::try_from(index)
.ok()
.and_then(|i| options.get(i))
.filter(|&name| name != "(none)" && name != "Custom RI\u{2026}")
.map(|name| {
name.strip_suffix(CUSTOM_BUILTIN_COLLISION_SUFFIX)
.map_or_else(|| name.clone(), str::to_string)
})
}
pub fn parse_design_material_form(
combo_index: i32,
ri_override_text: &str,
options: &[String],
current: &MaterialSelection,
) -> Result<MaterialSelection, String> {
let refractive_index_override = if ri_override_text.trim().is_empty() {
None
} else {
let value = eval_number(ri_override_text, None)
.map_err(|error| error.message("Refractive index", ri_override_text))?;
if !value.is_finite() || value <= 1.0 {
return Err(
"Refractive index override must be a finite number greater than 1.0.".to_string(),
);
}
Some(value)
};
let name = design_material_name_from_index(combo_index, options);
let same_material = match (name.as_deref(), current.name.as_deref()) {
(Some(new), Some(old)) => new.eq_ignore_ascii_case(old),
(None, None) => true,
_ => false,
};
Ok(MaterialSelection {
name,
specific_gravity_override: current.specific_gravity_override,
refractive_index_override,
body_color_override: current.body_color_override.filter(|_| same_material),
body_color_bands_override: current
.body_color_bands_override
.clone()
.filter(|_| same_material),
absorption_path_scale_override: current
.absorption_path_scale_override
.filter(|_| same_material),
})
}
#[must_use]
pub fn body_color_options() -> Vec<String> {
std::iter::once("Material default".to_string())
.chain(BODY_COLOR_PRESETS.iter().map(|p| p.label.to_string()))
.chain(std::iter::once(BODY_COLOR_CUSTOM_LABEL.to_string()))
.collect()
}
pub const BODY_COLOR_CUSTOM_LABEL: &str = "Custom\u{2026}";
#[must_use]
pub fn body_color_custom_index() -> i32 {
i32::try_from(BODY_COLOR_PRESETS.len() + 1).unwrap_or(i32::MAX)
}
#[must_use]
pub fn body_color_index_for(rgb: Option<[f32; 3]>) -> i32 {
rgb.map_or(0, |rgb| {
preset_index_for_rgb(rgb).map_or_else(body_color_custom_index, |index| index as i32 + 1)
})
}
#[must_use]
pub fn body_color_index_for_material(material: &MaterialSelection) -> i32 {
if material
.body_color_bands_override
.as_ref()
.is_some_and(|bands| !bands.is_empty())
{
body_color_custom_index()
} else {
body_color_index_for(material.body_color_override)
}
}
#[must_use]
pub fn body_color_from_index(index: i32) -> Option<[f32; 3]> {
usize::try_from(index)
.ok()
.and_then(|i| i.checked_sub(1))
.and_then(|i| BODY_COLOR_PRESETS.get(i))
.map(|preset| preset.absorption_rgb)
}
#[must_use]
pub fn body_color_for_apply(index: i32, current: Option<[f32; 3]>) -> Option<[f32; 3]> {
if index == body_color_custom_index() {
current
} else {
body_color_from_index(index)
}
}
#[must_use]
pub fn with_body_color_choice(
material: MaterialSelection,
index: i32,
current: &MaterialSelection,
) -> MaterialSelection {
if index == body_color_custom_index() {
material.with_body_color_bands(
current.body_color_override,
current.body_color_bands_override.clone(),
current.absorption_path_scale_override,
)
} else {
material.with_body_color(body_color_from_index(index))
}
}
#[must_use]
pub fn gear_index_from_teeth(gear_teeth: i32) -> i32 {
GEAR_PRESETS
.iter()
.position(|&g| g == gear_teeth)
.map_or(GEAR_PRESETS.len() as i32, |i| i as i32)
}
pub fn gear_choice_to_teeth(preset_index: i32, custom_text: &str) -> Result<i32, String> {
if let Ok(i) = usize::try_from(preset_index)
&& let Some(&teeth) = GEAR_PRESETS.get(i)
{
return Ok(teeth);
}
let teeth: i32 = custom_text.trim().parse().map_err(|_| {
format!(
"Gear tooth count '{}' is not a whole number.",
custom_text.trim()
)
})?;
if teeth <= 0 {
return Err("Gear tooth count must be a positive whole number.".to_string());
}
Ok(teeth)
}
#[must_use]
pub fn gear_remap_preview(
design: &Design,
from_gear: i32,
to_gear: i32,
rounding: RemapRounding,
) -> Vec<GearRemapPreviewRow> {
let format_indices = |v: &[f64]| v.iter().map(f64::to_string).collect::<Vec<_>>().join(", ");
let original: Vec<String> = design
.tiers
.iter()
.map(|t| format_indices(&t.indices))
.collect();
let ratio = indicatrix_cut_core::remap_ratio(from_gear, to_gear);
let non_integral: Vec<bool> = design
.tiers
.iter()
.map(|t| t.indices.iter().any(|&i| (i * ratio).fract() != 0.0))
.collect();
let mut remapped = design.clone();
if remapped
.apply_edit(Edit::RemapIndices {
from_gear,
to_gear,
rounding,
})
.is_err()
{
return Vec::new();
}
design
.tiers
.iter()
.zip(&remapped.tiers)
.enumerate()
.map(|(i, (before, after))| GearRemapPreviewRow {
name: before.name.clone(),
old_indices: original[i].clone(),
new_indices: format_indices(&after.indices),
non_integral: non_integral[i],
})
.collect()
}