feat(lines): multiple lines to a node

src/nodes/drawable/lines.rs

@@ -26,30 +26,42 @@ struct LinePointRaw {
 	thickness: f32,
 	color: [f32; 4],
 }
-
-#[derive(Debug, Clone)]
-struct LineData {
+#[derive(Debug, Clone, Deserialize)]
+struct Line {
 	points: Vec<LinePointRaw>,
 	cyclic: bool,
 }
+impl Line {
+	fn degamma(&mut self) {
+		for p in &mut self.points {
+			p.color[0] = p.color[0].powf(2.2);
+			p.color[1] = p.color[1].powf(2.2);
+			p.color[2] = p.color[2].powf(2.2);
+		}
+	}
+}
 
 pub struct Lines {
 	enabled: Arc<AtomicBool>,
 	space: Arc<Spatial>,
-	data: Mutex<LineData>,
+	data: Mutex<Vec<Line>>,
 }
 impl Lines {
-	fn add_to(node: &Arc<Node>, points: Vec<LinePointRaw>, cyclic: bool) -> Result<Arc<Lines>> {
+	fn add_to(node: &Arc<Node>, lines: Vec<Line>) -> Result<Arc<Lines>> {
 		ensure!(
 			node.drawable.get().is_none(),
 			"Internal: Node already has a drawable attached!"
 		);
 
 		let _ = node.spatial.get().unwrap().bounding_box_calc.set(|node| {
 			let mut bounds = Bounds::default();
-			let Some(Drawable::Lines(lines)) = node.drawable.get() else {return bounds};
-			for point in &lines.data.lock().points {
-				bounds = bounds_grow_to_fit_pt(bounds, point.point);
+			let Some(Drawable::Lines(lines)) = node.drawable.get() else {
+				return bounds;
+			};
+			for line in &*lines.data.lock() {
+				for point in &line.points {
+					bounds = bounds_grow_to_fit_pt(bounds, point.point);
+				}
 			}
 
 			bounds
@@ -58,10 +70,9 @@ impl Lines {
 		let lines = LINES_REGISTRY.add(Lines {
 			enabled: node.enabled.clone(),
 			space: node.get_aspect("Lines", "spatial", |n| &n.spatial)?.clone(),
-			data: Mutex::new(LineData { points, cyclic }),
+			data: Mutex::new(lines),
 		});
-		node.add_local_signal("set_points", Lines::set_points_flex);
-		node.add_local_signal("set_cyclic", Lines::set_cyclic_flex);
+		node.add_local_signal("set_lines", Lines::set_lines_flex);
 		let _ = node.drawable.set(Drawable::Lines(lines.clone()));
 
 		Ok(lines)
@@ -70,57 +81,57 @@ impl Lines {
 	fn draw(&self, draw_ctx: &impl StereoKitDraw) {
 		let transform_mat = self.space.global_transform();
 		let data = self.data.lock().clone();
-		let mut points: VecDeque<SkLinePoint> = data
-			.points
-			.iter()
-			.map(|p| SkLinePoint {
-				pt: transform_mat.transform_point3a(Vec3A::from(p.point)).into(),
-				thickness: p.thickness,
-				color: p.color.map(|c| (c * 255.0) as u8).into(),
-			})
-			.collect();
-		if data.cyclic && !points.is_empty() {
-			let first = data.points.first().unwrap();
-			let last = data.points.last().unwrap();
-			let color = Rgba::from_slice(&first.color).lerp(&Rgba::from_slice(&last.color), 0.5);
-			let connect_point = SkLinePoint {
-				pt: transform_mat
-					.transform_point3a(Vec3A::from(first.point).lerp(Vec3A::from(last.point), 0.5))
+		for line in &data {
+			let mut points: VecDeque<SkLinePoint> = line
+				.points
+				.iter()
+				.map(|p| SkLinePoint {
+					pt: transform_mat.transform_point3a(Vec3A::from(p.point)).into(),
+					thickness: p.thickness,
+					color: p.color.map(|c| (c * 255.0) as u8).into(),
+				})
+				.collect();
+			if line.cyclic && !points.is_empty() {
+				let first = line.points.first().unwrap();
+				let last = line.points.last().unwrap();
+				let color =
+					Rgba::from_slice(&first.color).lerp(&Rgba::from_slice(&last.color), 0.5);
+				let connect_point = SkLinePoint {
+					pt: transform_mat
+						.transform_point3a(
+							Vec3A::from(first.point).lerp(Vec3A::from(last.point), 0.5),
+						)
+						.into(),
+					thickness: (first.thickness + last.thickness) * 0.5,
+					color: Color128::from([
+						color.red(),
+						color.green(),
+						color.blue(),
+						color.alpha(),
+					])
 					.into(),
-				thickness: (first.thickness + last.thickness) * 0.5,
-				color: Color128::from([color.red(), color.green(), color.blue(), color.alpha()])
-					.into(),
-			};
-			points.push_front(connect_point.clone());
-			points.push_back(connect_point);
+				};
+				points.push_front(connect_point.clone());
+				points.push_back(connect_point);
+			}
+			draw_ctx.line_add_listv(points.make_contiguous());
 		}
-		draw_ctx.line_add_listv(points.make_contiguous());
 	}
 
-	pub fn set_points_flex(
+	pub fn set_lines_flex(
 		node: &Node,
 		_calling_client: Arc<Client>,
 		message: Message,
 	) -> Result<()> {
-		let Some(Drawable::Lines(lines)) = node.drawable.get() else {bail!("Not a drawable??")};
+		let Some(Drawable::Lines(lines)) = node.drawable.get() else {
+			bail!("Not a drawable??")
+		};
 
-		let mut points: Vec<LinePointRaw> = deserialize(message.as_ref())?;
-		for p in &mut points {
-			p.color[0] = p.color[0].powf(2.2);
-			p.color[1] = p.color[1].powf(2.2);
-			p.color[2] = p.color[2].powf(2.2);
+		let mut new_lines: Vec<Line> = deserialize(message.as_ref())?;
+		for l in &mut new_lines {
+			l.degamma();
 		}
-		lines.data.lock().points = points;
-		Ok(())
-	}
-	pub fn set_cyclic_flex(
-		node: &Node,
-		_calling_client: Arc<Client>,
-		message: Message,
-	) -> Result<()> {
-		let Some(Drawable::Lines(lines)) = node.drawable.get() else {bail!("Not a drawable??")};
-
-		lines.data.lock().cyclic = deserialize(message.as_ref())?;
+		*lines.data.lock() = new_lines;
 		Ok(())
 	}
 }
@@ -140,26 +151,23 @@ pub fn draw_all(draw_ctx: &impl StereoKitDraw) {
 
 pub fn create_flex(_node: &Node, calling_client: Arc<Client>, message: Message) -> Result<()> {
 	#[derive(Deserialize)]
-	struct CreateTextInfo<'a> {
+	struct CreateLinesInfo<'a> {
 		name: &'a str,
 		parent_path: &'a str,
 		transform: Transform,
-		points: Vec<LinePointRaw>,
-		cyclic: bool,
+		lines: Vec<Line>,
 	}
-	let mut info: CreateTextInfo = deserialize(message.as_ref())?;
+	let mut info: CreateLinesInfo = deserialize(message.as_ref())?;
 	let node = Node::create(&calling_client, "/drawable/lines", info.name, true);
 	let parent = find_spatial_parent(&calling_client, info.parent_path)?;
 	let transform = parse_transform(info.transform, true, true, true);
 
-	for p in &mut info.points {
-		p.color[0] = p.color[0].powf(2.2);
-		p.color[1] = p.color[1].powf(2.2);
-		p.color[2] = p.color[2].powf(2.2);
+	for l in &mut info.lines {
+		l.degamma();
 	}
 
 	let node = node.add_to_scenegraph()?;
 	Spatial::add_to(&node, Some(parent), transform, false)?;
-	Lines::add_to(&node, info.points, info.cyclic)?;
+	Lines::add_to(&node, info.lines)?;
 	Ok(())
 }