use serde::{Deserialize, Serialize};
pub type Color = [f64; 4];
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ViewState {
pub visibility: bool,
pub transparency: i32,
pub default_color: Color,
#[serde(default)]
pub shape_color: Option<Color>,
#[serde(default)]
pub diffuse_color: Option<Vec<Color>>,
#[serde(default)]
pub appearance: Vec<Color>,
#[serde(default)]
pub material: Option<Color>,
#[serde(default = "default_display_mode")]
pub display_mode: String,
}
fn default_display_mode() -> String {
"Flat Lines".to_string()
}
impl ViewState {
pub fn new(transparency: i32, default_color: Color) -> Self {
Self {
visibility: true,
transparency: transparency.clamp(0, 100),
default_color,
shape_color: None,
diffuse_color: None,
appearance: Vec::new(),
material: None,
display_mode: default_display_mode(),
}
}
pub fn effective_color(&self) -> Color {
self.shape_color.unwrap_or(self.default_color)
}
pub fn appearance(&self) -> Vec<Color> {
if self.appearance.is_empty() {
vec![self.effective_color()]
} else {
self.appearance.clone()
}
}
pub fn material(&self) -> Color {
self.material.unwrap_or_else(|| self.effective_color())
}
pub fn set_shape_color(&mut self, color: Color) {
self.shape_color = Some(color);
if let Some(first) = self.appearance.first_mut() {
*first = color;
}
}
pub fn set_appearance_slot(&mut self, index: usize, color: Color) {
if self.appearance.is_empty() {
self.appearance = vec![self.effective_color()];
}
if index >= self.appearance.len() {
let fill = self.effective_color();
self.appearance.resize(index + 1, fill);
}
self.appearance[index] = color;
if index == 0 {
self.shape_color = Some(color);
}
}
pub fn set_appearance(&mut self, colors: Vec<Color>) {
if colors.is_empty() {
self.appearance.clear();
return;
}
self.shape_color = Some(colors[0]);
self.appearance = colors;
}
}
pub fn color_from_packed(packed: u32, opaque_if_alpha_zero: bool) -> Color {
let red = ((packed >> 24) & 0xFF) as f64 / 255.0;
let green = ((packed >> 16) & 0xFF) as f64 / 255.0;
let blue = ((packed >> 8) & 0xFF) as f64 / 255.0;
let alpha = (packed & 0xFF) as f64 / 255.0;
let alpha = if opaque_if_alpha_zero && alpha == 0.0 {
1.0
} else {
alpha
};
[red, green, blue, alpha]
}
pub fn color_to_packed(color: Color) -> u32 {
let byte = |v: f64| (v.clamp(0.0, 1.0) * 255.0).round() as u32;
(byte(color[0]) << 24) | (byte(color[1]) << 16) | (byte(color[2]) << 8) | byte(color[3])
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn packed_color_is_rgba() {
assert_eq!(color_from_packed(0xFF00_00FF, false), [1.0, 0.0, 0.0, 1.0]);
assert_eq!(color_from_packed(0x00FF_00FF, false), [0.0, 1.0, 0.0, 1.0]);
assert_eq!(color_from_packed(0x0000_FFFF, false), [0.0, 0.0, 1.0, 1.0]);
assert_eq!(color_from_packed(0xFF00_0000, false), [1.0, 0.0, 0.0, 0.0]);
}
#[test]
fn default_color_treats_zero_alpha_as_opaque() {
assert_eq!(color_from_packed(0xFF00_0000, true), [1.0, 0.0, 0.0, 1.0]);
}
#[test]
fn packed_round_trip() {
let [r, g, b, a] = color_from_packed(0xADB5_BDFF, false);
assert_eq!(color_to_packed([r, g, b, a]), 0xADB5_BDFF);
}
#[test]
fn shape_color_updates_the_derived_views() {
let mut state = ViewState::new(0, [0.8, 0.8, 0.8, 1.0]);
assert_eq!(state.appearance(), vec![[0.8, 0.8, 0.8, 1.0]]);
assert_eq!(state.material(), [0.8, 0.8, 0.8, 1.0]);
state.set_shape_color([1.0, 0.0, 0.0, 1.0]);
assert_eq!(state.effective_color(), [1.0, 0.0, 0.0, 1.0]);
assert_eq!(state.material(), [1.0, 0.0, 0.0, 1.0]);
state.set_appearance_slot(0, [0.0, 1.0, 0.0, 1.0]);
assert_eq!(state.appearance(), vec![[0.0, 1.0, 0.0, 1.0]]);
assert_eq!(state.material(), [0.0, 1.0, 0.0, 1.0]);
state.material = Some([0.0, 0.0, 1.0, 1.0]);
assert_eq!(state.material(), [0.0, 0.0, 1.0, 1.0]);
}
#[test]
fn transparency_is_independent_of_colour() {
let mut state = ViewState::new(70, [1.0, 1.0, 1.0, 1.0]);
state.set_appearance_slot(0, [0.5, 0.0, 0.0, 1.0]);
assert_eq!(state.transparency, 70);
}
}