1use std::fmt;
14
15use std::rc::Rc;
16
17use crate::core::BufferGeometry;
18use crate::lights::LightObject;
19use crate::materials::MeshBasicNodeMaterial;
20use crate::math::{Matrix4, Sphere};
21use crate::objects::{
22 BatchedMesh, ClippingGroup, InstancedBufferAttribute, InstancedMesh, Line, Mesh, Points,
23 SkinnedMesh, Sprite,
24};
25
26#[derive(Clone, Default)]
31#[non_exhaustive]
32pub enum Payload {
33 #[default]
35 None,
36 Mesh(Mesh),
38 InstancedMesh(InstancedMesh),
40 SkinnedMesh(Box<SkinnedMesh>),
46 BatchedMesh(Box<BatchedMesh>),
49 Line(Line),
53 Points(Points),
56 Sprite(Sprite),
60 Light(LightObject),
64 ClippingGroup(ClippingGroup),
67}
68
69impl fmt::Debug for Payload {
70 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
73 let name = match self {
74 Payload::None => "None",
75 Payload::Mesh(_) => "Mesh",
76 Payload::InstancedMesh(_) => "InstancedMesh",
77 Payload::SkinnedMesh(_) => "SkinnedMesh",
78 Payload::BatchedMesh(_) => "BatchedMesh",
79 Payload::Line(line) => {
80 if line.is_line_segments {
81 "LineSegments"
82 } else {
83 "Line"
84 }
85 }
86 Payload::Points(_) => "Points",
87 Payload::Sprite(_) => "Sprite",
88 Payload::Light(_) => "Light",
89 Payload::ClippingGroup(_) => "ClippingGroup",
90 };
91 f.write_str(name)
92 }
93}
94
95impl Payload {
96 pub fn is_mesh(&self) -> bool {
99 matches!(
100 self,
101 Payload::Mesh(_)
102 | Payload::InstancedMesh(_)
103 | Payload::SkinnedMesh(_)
104 | Payload::BatchedMesh(_)
105 )
106 }
107
108 pub fn is_skinned_mesh(&self) -> bool {
110 matches!(self, Payload::SkinnedMesh(_))
111 }
112
113 pub fn skinned_mesh(&self) -> Option<&SkinnedMesh> {
115 match self {
116 Payload::SkinnedMesh(skin) => Some(skin),
117 _ => None,
118 }
119 }
120
121 pub fn skinned_mesh_mut(&mut self) -> Option<&mut SkinnedMesh> {
123 match self {
124 Payload::SkinnedMesh(skin) => Some(skin),
125 _ => None,
126 }
127 }
128
129 pub fn is_instanced_mesh(&self) -> bool {
131 matches!(self, Payload::InstancedMesh(_))
132 }
133
134 pub fn is_line(&self) -> bool {
137 matches!(self, Payload::Line(_))
138 }
139
140 pub fn is_line_segments(&self) -> bool {
142 matches!(self, Payload::Line(line) if line.is_line_segments)
143 }
144
145 pub fn is_points(&self) -> bool {
147 matches!(self, Payload::Points(_))
148 }
149
150 pub fn is_sprite(&self) -> bool {
152 matches!(self, Payload::Sprite(_))
153 }
154
155 pub fn is_clipping_group(&self) -> bool {
157 matches!(self, Payload::ClippingGroup(_))
158 }
159
160 pub fn clipping_group(&self) -> Option<&ClippingGroup> {
162 match self {
163 Payload::ClippingGroup(group) => Some(group),
164 _ => None,
165 }
166 }
167
168 pub fn clipping_group_mut(&mut self) -> Option<&mut ClippingGroup> {
170 match self {
171 Payload::ClippingGroup(group) => Some(group),
172 _ => None,
173 }
174 }
175
176 pub fn sprite(&self) -> Option<&Sprite> {
178 match self {
179 Payload::Sprite(sprite) => Some(sprite),
180 _ => None,
181 }
182 }
183
184 pub fn sprite_mut(&mut self) -> Option<&mut Sprite> {
186 match self {
187 Payload::Sprite(sprite) => Some(sprite),
188 _ => None,
189 }
190 }
191
192 pub fn points(&self) -> Option<&Points> {
194 match self {
195 Payload::Points(points) => Some(points),
196 _ => None,
197 }
198 }
199
200 pub fn points_mut(&mut self) -> Option<&mut Points> {
202 match self {
203 Payload::Points(points) => Some(points),
204 _ => None,
205 }
206 }
207
208 pub fn line(&self) -> Option<&Line> {
210 match self {
211 Payload::Line(line) => Some(line),
212 _ => None,
213 }
214 }
215
216 pub fn line_mut(&mut self) -> Option<&mut Line> {
218 match self {
219 Payload::Line(line) => Some(line),
220 _ => None,
221 }
222 }
223
224 pub fn geometry(&self) -> Option<&Rc<BufferGeometry>> {
227 match self {
228 Payload::Mesh(mesh) => Some(&mesh.geometry),
229 Payload::InstancedMesh(instanced) => Some(&instanced.mesh.geometry),
230 Payload::SkinnedMesh(skin) => Some(&skin.mesh.geometry),
231 Payload::BatchedMesh(batched) => Some(&batched.mesh.geometry),
232 Payload::Line(line) => Some(&line.geometry),
233 Payload::Points(points) => Some(&points.geometry),
234 Payload::Sprite(sprite) => Some(&sprite.geometry),
235 _ => None,
236 }
237 }
238
239 pub fn material(&self) -> Option<&MeshBasicNodeMaterial> {
243 match self {
244 Payload::Mesh(mesh) => mesh.material.as_ref(),
245 Payload::InstancedMesh(instanced) => instanced.mesh.material.as_ref(),
246 Payload::SkinnedMesh(skin) => skin.mesh.material.as_ref(),
247 Payload::BatchedMesh(batched) => batched.mesh.material.as_ref(),
248 Payload::Line(line) => line.material.as_ref(),
249 Payload::Points(points) => points.material.as_ref(),
250 Payload::Sprite(sprite) => Some(&sprite.material),
251 _ => None,
252 }
253 }
254
255 pub fn material_mut(&mut self) -> Option<&mut MeshBasicNodeMaterial> {
258 match self {
259 Payload::Mesh(mesh) => mesh.material.as_mut(),
260 Payload::InstancedMesh(instanced) => instanced.mesh.material.as_mut(),
261 Payload::SkinnedMesh(skin) => skin.mesh.material.as_mut(),
262 Payload::BatchedMesh(batched) => batched.mesh.material.as_mut(),
263 Payload::Line(line) => line.material.as_mut(),
264 Payload::Points(points) => points.material.as_mut(),
265 Payload::Sprite(sprite) => Some(&mut sprite.material),
266 _ => None,
267 }
268 }
269
270 pub(crate) fn material_array(&self) -> &[MeshBasicNodeMaterial] {
274 match self {
275 Payload::Mesh(mesh) => &mesh.materials,
276 _ => &[],
277 }
278 }
279
280 pub(crate) fn bounding_sphere_in(&self, matrix_world: &Matrix4) -> Option<Sphere> {
289 match self {
290 Payload::Line(line) => line.bounding_sphere_in(matrix_world),
291 Payload::Points(points) => points.bounding_sphere_in(matrix_world),
292 Payload::Sprite(sprite) => Some(sprite.bounding_sphere_in(matrix_world)),
295 Payload::InstancedMesh(instanced) => match instanced.bounding_sphere {
296 Some(bounding_sphere) => {
297 let mut sphere = bounding_sphere;
298 sphere.apply_matrix4(matrix_world);
299 Some(sphere)
300 }
301 None => instanced.mesh.bounding_sphere_in(matrix_world),
302 },
303 Payload::SkinnedMesh(skin) => match skin.bounding_sphere {
307 Some(bounding_sphere) => {
308 let mut sphere = bounding_sphere;
309 sphere.apply_matrix4(matrix_world);
310 Some(sphere)
311 }
312 None => skin.mesh.bounding_sphere_in(matrix_world),
313 },
314 _ => self.mesh()?.bounding_sphere_in(matrix_world),
315 }
316 }
317
318 pub fn morph_target_influences(&self) -> Vec<f64> {
324 match self {
325 Payload::SkinnedMesh(skin) => skin.morph_target_influences.borrow().clone(),
326 _ => match self.mesh() {
327 Some(mesh) => mesh.morph_target_influences.clone(),
328 None => Vec::new(),
329 },
330 }
331 }
332
333 pub fn mesh(&self) -> Option<&Mesh> {
335 match self {
336 Payload::Mesh(mesh) => Some(mesh),
337 Payload::InstancedMesh(instanced) => Some(&instanced.mesh),
338 Payload::SkinnedMesh(skin) => Some(&skin.mesh),
339 Payload::BatchedMesh(batched) => Some(&batched.mesh),
340 _ => None,
341 }
342 }
343
344 pub fn mesh_mut(&mut self) -> Option<&mut Mesh> {
346 match self {
347 Payload::Mesh(mesh) => Some(mesh),
348 Payload::InstancedMesh(instanced) => Some(&mut instanced.mesh),
349 Payload::SkinnedMesh(skin) => Some(&mut skin.mesh),
350 Payload::BatchedMesh(batched) => Some(&mut batched.mesh),
351 _ => None,
352 }
353 }
354
355 pub fn light(&self) -> Option<&LightObject> {
357 match self {
358 Payload::Light(light) => Some(light),
359 _ => None,
360 }
361 }
362
363 pub fn light_mut(&mut self) -> Option<&mut LightObject> {
365 match self {
366 Payload::Light(light) => Some(light),
367 _ => None,
368 }
369 }
370
371 pub fn is_batched_mesh(&self) -> bool {
373 matches!(self, Payload::BatchedMesh(_))
374 }
375
376 pub fn batched_mesh(&self) -> Option<&BatchedMesh> {
378 match self {
379 Payload::BatchedMesh(batched) => Some(batched),
380 _ => None,
381 }
382 }
383
384 pub fn batched_mesh_mut(&mut self) -> Option<&mut BatchedMesh> {
386 match self {
387 Payload::BatchedMesh(batched) => Some(batched),
388 _ => None,
389 }
390 }
391
392 pub fn instanced_mesh(&self) -> Option<&InstancedMesh> {
394 match self {
395 Payload::InstancedMesh(instanced) => Some(instanced),
396 _ => None,
397 }
398 }
399
400 pub fn instanced_mesh_mut(&mut self) -> Option<&mut InstancedMesh> {
402 match self {
403 Payload::InstancedMesh(instanced) => Some(instanced),
404 _ => None,
405 }
406 }
407
408 pub(crate) fn count(&self) -> u32 {
412 match self {
413 Payload::InstancedMesh(instanced) => instanced.count as u32,
414 Payload::Points(points) => points.count.unwrap_or(1) as u32,
415 Payload::Sprite(sprite) => sprite.count as u32,
416 Payload::Mesh(mesh) => mesh.count.unwrap_or(1) as u32,
419 _ => 1,
420 }
421 }
422
423 pub fn instance_matrix(&self) -> Option<&InstancedBufferAttribute> {
425 match self {
426 Payload::InstancedMesh(instanced) => Some(&instanced.instance_matrix),
427 _ => None,
428 }
429 }
430
431 pub fn instance_color(&self) -> Option<&InstancedBufferAttribute> {
434 match self {
435 Payload::InstancedMesh(instanced) => instanced.instance_color.as_ref(),
436 _ => None,
437 }
438 }
439}