1extern crate gltf;
2extern crate nalgebra;
3
4use std::ops::Index;
5use gltf::{Accessor, buffer};
6use crate::util;
7use std::sync::{Arc, Mutex};
8use gltf::accessor::Dimensions;
9use gltf::buffer::View;
10use gltf::json::Value;
11use nalgebra::{Matrix2, Matrix3, Matrix4, SMatrix, SVector, Vector2, Vector3, Vector4};
12
13pub struct LoadedGltfBuffer {
14 gltf: Arc<Mutex<LoadedGltf>>,
15 index: usize,
16 uri: String,
17 data: Vec<u8>
18}
19
20pub struct LoadedGltfBufferView {
21 gltf: Arc<Mutex<LoadedGltf>>,
22 index: usize,
23 buffer_index: usize,
24 data_offset: usize,
25 data_length: usize,
26 data_stride: Option<usize>,
27 target: Option<buffer::Target>
28}
29
30pub struct LoadedGltfAccessor {
31 gltf: Arc<Mutex<LoadedGltf>>,
32 index: usize,
33 buffer_view_index: usize,
34 comp_size: usize,
35 comp_count: usize,
36 max_values: Option<Vec<Value>>,
37 min_values: Option<Vec<Value>>,
38 dimensions: Dimensions
39}
40
41pub struct LoadedGltfImage {
42 gltf: Arc<Mutex<LoadedGltf>>,
43 index: usize,
44 uri: String,
45 data: Vec<u8>
46}
47
48pub struct LoadedGltf {
49 buffers: Vec<LoadedGltfBuffer>,
50 buffer_views: Vec<LoadedGltfBufferView>,
51 accessors: Vec<LoadedGltfAccessor>,
52 images: Vec<LoadedGltfImage>
53}
54
55pub struct LoadedGltfWrapper {
56 gltf: Arc<Mutex<LoadedGltf>>
57}
58
59impl LoadedGltfBuffer {
60 pub fn new(gltf: &Arc<Mutex<LoadedGltf>>, index: usize, uri: String, data: Vec<u8>) -> Self {
61 Self {
62 gltf: Arc::clone(gltf),
63 index,
64 uri,
65 data
66 }
67 }
68
69 pub fn get_gltf(&self) -> Arc<Mutex<LoadedGltf>> {
70 Arc::clone(&self.gltf)
71 }
72
73 pub fn get_index(&self) -> usize {
74 self.index
75 }
76
77 pub fn get_uri(&self) -> &String {
78 &self.uri
79 }
80
81 pub fn get_data(&self) -> &Vec<u8> {
82 &self.data
83 }
84
85 pub fn get_data_ptr(&self) -> *const u8 {
86 self.data.as_ptr()
87 }
88}
89
90type GltfPosNum = f32;
91
92pub enum LoadedGltfAccessorDatum {
93 Scalar(GltfPosNum),
94 Vec2(SVector<GltfPosNum, 2>),
95 Vec3(SVector<GltfPosNum, 3>),
96 Vec4(SVector<GltfPosNum, 4>),
97 Mat2(SMatrix<GltfPosNum, 2, 2>),
98 Mat3(SMatrix<GltfPosNum, 3, 3>),
99 Mat4(SMatrix<GltfPosNum, 4, 4>)
100}
101
102impl LoadedGltfBufferView {
103 pub fn new(
104 gltf: &Arc<Mutex<LoadedGltf>>,
105 index: usize,
106 buffer_index: usize,
107 data_offset: usize,
108 data_length: usize,
109 data_stride: Option<usize>,
110 target: Option<buffer::Target>
111 ) -> Self {
112 Self {
113 gltf: Arc::clone(gltf),
114 index,
115 buffer_index,
116 data_offset,
117 data_length,
118 data_stride,
119 target
120 }
121 }
122
123 pub fn new_from_view(gltf: &Arc<Mutex<LoadedGltf>>, view: &View) -> Self {
124 Self::new(gltf, view.index(), view.buffer().index(), view.offset(),
125 view.length(), view.stride(), view.target())
126 }
127
128 pub fn get_gltf(&self) -> Arc<Mutex<LoadedGltf>> {
129 Arc::clone(&self.gltf)
130 }
131
132 pub fn get_buffer_index(&self) -> usize {
133 self.buffer_index
134 }
135
136 pub fn get_index(&self) -> usize {
137 self.index
138 }
139
140 pub fn get_data_offset(&self) -> usize {
141 self.data_offset
142 }
143
144 pub fn get_data_length(&self) -> usize {
145 self.data_length
146 }
147
148 pub fn get_data_stride(&self) -> Option<usize> {
149 self.data_stride
150 }
151
152 pub fn get_target(&self) -> Option<buffer::Target> {
153 self.target
154 }
155
156 pub fn load_data(&self) -> Vec<u8> {
157 self.load_data_strided(0)
158 }
159
160 pub fn load_data_strided(&self, stride_count: u32) -> Vec<u8> {
161 let gltf = self.gltf.lock().unwrap();
162 let buffer = gltf.get_buffers().get(self.buffer_index).unwrap();
163 let mut result = util::new_buffer_vec(self.data_length, 0u8);
164 let result_ptr = result.as_mut_ptr();
165 unsafe {
166 let data_ptr = buffer.get_data_ptr().add(self.data_offset)
167 .add((stride_count as usize) * self.data_stride.unwrap_or(0));
168 let mut result_ptrm = result_ptr;
169 let mut data_ptrm = data_ptr;
170 for _ in 0..self.data_length {
171 *result_ptrm = *data_ptrm;
172 result_ptrm = result_ptrm.add(1);
173 data_ptrm = data_ptrm.add(1);
174 }
175 }
176 result
177 }
178}
179
180impl LoadedGltfAccessor {
181 pub fn new(
182 gltf: &Arc<Mutex<LoadedGltf>>,
183 index: usize,
184 buffer_view_index: usize,
185 comp_size: usize,
186 comp_count: usize,
187 max_values: Option<Vec<Value>>,
188 min_values: Option<Vec<Value>>,
189 dimensions: Dimensions
190 ) -> Self {
191 Self {
192 gltf: Arc::clone(gltf),
193 index,
194 buffer_view_index,
195 comp_size,
196 comp_count,
197 max_values,
198 min_values,
199 dimensions
200 }
201 }
202
203 pub fn new_from_accessor(
204 gltf: &Arc<Mutex<LoadedGltf>>,
205 accessor: &Accessor
206 ) -> Option<Self> {
207 if let Some(max_val) = accessor.max() {
208 if let Value::Array(max_val_arr) = max_val {
209 if let Some(min_val) = accessor.min() {
210 if let Value::Array(min_val_arr) = min_val {
211 Some(Self::new(
212 gltf, accessor.index(), accessor.view().unwrap().index(),accessor.size(),
213 accessor.count(), Some(max_val_arr), Some(min_val_arr), accessor.dimensions()))
214 } else {
215 Some(Self::new(
216 gltf, accessor.index(), accessor.view().unwrap().index(),
217 accessor.size(), accessor.count(), Some(max_val_arr), None, accessor.dimensions()))
218 }
219 } else {
220 Some(Self::new(
221 gltf, accessor.index(), accessor.view().unwrap().index(),
222 accessor.size(), accessor.count(), Some(max_val_arr), None, accessor.dimensions()))
223 }
224 } else if let Some(min_val) = accessor.min() {
225 if let Value::Array(min_val_arr) = min_val {
226 Some(Self::new(
227 gltf, accessor.index(), accessor.view().unwrap().index(),
228 accessor.size(), accessor.count(), None, Some(min_val_arr), accessor.dimensions()))
229 } else {
230 Some(Self::new(
231 gltf, accessor.index(), accessor.view().unwrap().index(),
232 accessor.size(), accessor.count(), None, None, accessor.dimensions()))
233 }
234 } else {
235 Some(Self::new(
236 gltf, accessor.index(), accessor.view().unwrap().index(),
237 accessor.size(), accessor.count(), None, None, accessor.dimensions()))
238 }
239 } else if let Some(min_val) = accessor.min() {
240 if let Value::Array(min_val_arr) = min_val {
241 Some(Self::new(
242 gltf, accessor.index(), accessor.view().unwrap().index(),
243 accessor.size(), accessor.count(), None, Some(min_val_arr), accessor.dimensions()))
244 } else {
245 Some(Self::new(
246 gltf, accessor.index(), accessor.view().unwrap().index(),
247 accessor.size(), accessor.count(), None, None, accessor.dimensions()))
248 }
249 } else {
250 Some(Self::new(
251 gltf, accessor.index(), accessor.view().unwrap().index(),
252 accessor.size(), accessor.count(), None, None, accessor.dimensions()))
253 }
254 }
255
256 pub fn get_gltf(&self) -> Arc<Mutex<LoadedGltf>> {
257 Arc::clone(&self.gltf)
258 }
259
260 pub fn get_index(&self) -> usize {
261 self.index
262 }
263
264 pub fn get_buffer_view_index(&self) -> usize {
265 self.buffer_view_index
266 }
267
268 pub fn get_comp_size(&self) -> usize {
269 self.comp_size
270 }
271
272 pub fn get_comp_count(&self) -> usize {
273 self.comp_count
274 }
275
276 pub fn get_max_values(&self) -> Option<Vec<Value>> {
277 self.max_values.clone()
278 }
279
280 pub fn get_min_values(&self) -> Option<Vec<Value>> {
281 self.min_values.clone()
282 }
283
284 pub fn get_dimensions(&self) -> Dimensions {
285 self.dimensions
286 }
287
288 pub fn load_data(&self) -> Vec<LoadedGltfAccessorDatum> {
289 let gltf = self.gltf.lock().unwrap();
290 let buffer_view = gltf.buffer_views.get(self.buffer_view_index).unwrap();
291 let mut result = Vec::new();
292
293 for i in 0..self.comp_count {
294 let datum_content = buffer_view.load_data_strided(i as u32);
295 let datum = match self.dimensions {
296 Dimensions::Scalar => {
297 let a0 = *datum_content.index(0);
298 let a1 = *datum_content.index(1);
299 let a2 = *datum_content.index(2);
300 let a3 = *datum_content.index(3);
301
302 let a = util::bits::u8_to_f32((a0, a1, a2, a3));
303
304 LoadedGltfAccessorDatum::scalar_of(a)
305 }
306 Dimensions::Vec2 => {
307 let x0 = *datum_content.index(0);
308 let x1 = *datum_content.index(1);
309 let x2 = *datum_content.index(2);
310 let x3 = *datum_content.index(3);
311 let y0 = *datum_content.index(4);
312 let y1 = *datum_content.index(5);
313 let y2 = *datum_content.index(6);
314 let y3 = *datum_content.index(7);
315
316 let x = util::bits::u8_to_f32((x0, x1, x2, x3));
317 let y = util::bits::u8_to_f32((y0, y1, y2, y3));
318
319 LoadedGltfAccessorDatum::vec2_of(x, y)
320 }
321 Dimensions::Vec3 => {
322 let x0 = *datum_content.index(0);
323 let x1 = *datum_content.index(1);
324 let x2 = *datum_content.index(2);
325 let x3 = *datum_content.index(3);
326 let y0 = *datum_content.index(4);
327 let y1 = *datum_content.index(5);
328 let y2 = *datum_content.index(6);
329 let y3 = *datum_content.index(7);
330 let z0 = *datum_content.index(8);
331 let z1 = *datum_content.index(9);
332 let z2 = *datum_content.index(10);
333 let z3 = *datum_content.index(11);
334
335 let x = util::bits::u8_to_f32((x0, x1, x2, x3));
336 let y = util::bits::u8_to_f32((y0, y1, y2, y3));
337 let z = util::bits::u8_to_f32((z0, z1, z2, z3));
338
339 LoadedGltfAccessorDatum::vec3_of(x, y, z)
340 }
341 Dimensions::Vec4 => {
342 let x0 = *datum_content.index(0);
343 let x1 = *datum_content.index(1);
344 let x2 = *datum_content.index(2);
345 let x3 = *datum_content.index(3);
346 let y0 = *datum_content.index(4);
347 let y1 = *datum_content.index(5);
348 let y2 = *datum_content.index(6);
349 let y3 = *datum_content.index(7);
350 let z0 = *datum_content.index(8);
351 let z1 = *datum_content.index(9);
352 let z2 = *datum_content.index(10);
353 let z3 = *datum_content.index(11);
354 let w0 = *datum_content.index(12);
355 let w1 = *datum_content.index(13);
356 let w2 = *datum_content.index(14);
357 let w3 = *datum_content.index(15);
358
359 let x = util::bits::u8_to_f32((x0, x1, x2, x3));
360 let y = util::bits::u8_to_f32((y0, y1, y2, y3));
361 let z = util::bits::u8_to_f32((z0, z1, z2, z3));
362 let w = util::bits::u8_to_f32((w0, w1, w2, w3));
363
364 LoadedGltfAccessorDatum::vec4_of(x, y, z, w)
365 }
366 Dimensions::Mat2 => {
367 let a00_0 = *datum_content.index(0);
368 let a00_1 = *datum_content.index(1);
369 let a00_2 = *datum_content.index(2);
370 let a00_3 = *datum_content.index(3);
371
372 let a01_0 = *datum_content.index(4);
373 let a01_1 = *datum_content.index(5);
374 let a01_2 = *datum_content.index(6);
375 let a01_3 = *datum_content.index(7);
376
377 let a10_0 = *datum_content.index(8);
378 let a10_1 = *datum_content.index(9);
379 let a10_2 = *datum_content.index(10);
380 let a10_3 = *datum_content.index(11);
381
382 let a11_0 = *datum_content.index(12);
383 let a11_1 = *datum_content.index(13);
384 let a11_2 = *datum_content.index(14);
385 let a11_3 = *datum_content.index(15);
386
387 let a00 = util::bits::u8_to_f32((a00_0, a00_1, a00_2, a00_3));
388 let a01 = util::bits::u8_to_f32((a01_0, a01_1, a01_2, a01_3));
389 let a10 = util::bits::u8_to_f32((a10_0, a10_1, a10_2, a10_3));
390 let a11 = util::bits::u8_to_f32((a11_0, a11_1, a11_2, a11_3));
391
392 LoadedGltfAccessorDatum::mat2_of(
393 a00, a01,
394 a10, a11
395 )
396 }
397 Dimensions::Mat3 => {
398 let a00_0 = *datum_content.index(0);
399 let a00_1 = *datum_content.index(1);
400 let a00_2 = *datum_content.index(2);
401 let a00_3 = *datum_content.index(3);
402
403 let a01_0 = *datum_content.index(4);
404 let a01_1 = *datum_content.index(5);
405 let a01_2 = *datum_content.index(6);
406 let a01_3 = *datum_content.index(7);
407
408 let a02_0 = *datum_content.index(8);
409 let a02_1 = *datum_content.index(9);
410 let a02_2 = *datum_content.index(10);
411 let a02_3 = *datum_content.index(11);
412
413 let a10_0 = *datum_content.index(12);
414 let a10_1 = *datum_content.index(13);
415 let a10_2 = *datum_content.index(14);
416 let a10_3 = *datum_content.index(15);
417
418 let a11_0 = *datum_content.index(16);
419 let a11_1 = *datum_content.index(17);
420 let a11_2 = *datum_content.index(18);
421 let a11_3 = *datum_content.index(19);
422
423 let a12_0 = *datum_content.index(20);
424 let a12_1 = *datum_content.index(21);
425 let a12_2 = *datum_content.index(22);
426 let a12_3 = *datum_content.index(23);
427
428 let a20_0 = *datum_content.index(24);
429 let a20_1 = *datum_content.index(25);
430 let a20_2 = *datum_content.index(26);
431 let a20_3 = *datum_content.index(27);
432
433 let a21_0 = *datum_content.index(28);
434 let a21_1 = *datum_content.index(29);
435 let a21_2 = *datum_content.index(30);
436 let a21_3 = *datum_content.index(31);
437
438 let a22_0 = *datum_content.index(32);
439 let a22_1 = *datum_content.index(33);
440 let a22_2 = *datum_content.index(34);
441 let a22_3 = *datum_content.index(35);
442
443 let a00 = util::bits::u8_to_f32((a00_0, a00_1, a00_2, a00_3));
444 let a01 = util::bits::u8_to_f32((a01_0, a01_1, a01_2, a01_3));
445 let a02 = util::bits::u8_to_f32((a02_0, a02_1, a02_2, a02_3));
446 let a10 = util::bits::u8_to_f32((a10_0, a10_1, a10_2, a10_3));
447 let a11 = util::bits::u8_to_f32((a11_0, a11_1, a11_2, a11_3));
448 let a12 = util::bits::u8_to_f32((a12_0, a12_1, a12_2, a12_3));
449 let a20 = util::bits::u8_to_f32((a20_0, a20_1, a20_2, a20_3));
450 let a21 = util::bits::u8_to_f32((a21_0, a21_1, a21_2, a21_3));
451 let a22 = util::bits::u8_to_f32((a22_0, a22_1, a22_2, a22_3));
452
453 LoadedGltfAccessorDatum::mat3_of(
454 a00, a01, a02,
455 a10, a11, a12,
456 a20, a21, a22
457 )
458 }
459 Dimensions::Mat4 => {
460 let a00_0 = *datum_content.index(0);
461 let a00_1 = *datum_content.index(1);
462 let a00_2 = *datum_content.index(2);
463 let a00_3 = *datum_content.index(3);
464
465 let a01_0 = *datum_content.index(4);
466 let a01_1 = *datum_content.index(5);
467 let a01_2 = *datum_content.index(6);
468 let a01_3 = *datum_content.index(7);
469
470 let a02_0 = *datum_content.index(8);
471 let a02_1 = *datum_content.index(9);
472 let a02_2 = *datum_content.index(10);
473 let a02_3 = *datum_content.index(11);
474
475 let a03_0 = *datum_content.index(12);
476 let a03_1 = *datum_content.index(13);
477 let a03_2 = *datum_content.index(14);
478 let a03_3 = *datum_content.index(15);
479
480 let a10_0 = *datum_content.index(16);
481 let a10_1 = *datum_content.index(17);
482 let a10_2 = *datum_content.index(18);
483 let a10_3 = *datum_content.index(19);
484
485 let a11_0 = *datum_content.index(20);
486 let a11_1 = *datum_content.index(21);
487 let a11_2 = *datum_content.index(22);
488 let a11_3 = *datum_content.index(23);
489
490 let a12_0 = *datum_content.index(24);
491 let a12_1 = *datum_content.index(25);
492 let a12_2 = *datum_content.index(26);
493 let a12_3 = *datum_content.index(27);
494
495 let a13_0 = *datum_content.index(28);
496 let a13_1 = *datum_content.index(29);
497 let a13_2 = *datum_content.index(30);
498 let a13_3 = *datum_content.index(31);
499
500 let a20_0 = *datum_content.index(32);
501 let a20_1 = *datum_content.index(33);
502 let a20_2 = *datum_content.index(34);
503 let a20_3 = *datum_content.index(35);
504
505 let a21_0 = *datum_content.index(36);
506 let a21_1 = *datum_content.index(37);
507 let a21_2 = *datum_content.index(38);
508 let a21_3 = *datum_content.index(39);
509
510 let a22_0 = *datum_content.index(40);
511 let a22_1 = *datum_content.index(41);
512 let a22_2 = *datum_content.index(42);
513 let a22_3 = *datum_content.index(43);
514
515 let a23_0 = *datum_content.index(44);
516 let a23_1 = *datum_content.index(45);
517 let a23_2 = *datum_content.index(46);
518 let a23_3 = *datum_content.index(47);
519
520 let a30_0 = *datum_content.index(48);
521 let a30_1 = *datum_content.index(49);
522 let a30_2 = *datum_content.index(50);
523 let a30_3 = *datum_content.index(51);
524
525 let a31_0 = *datum_content.index(52);
526 let a31_1 = *datum_content.index(53);
527 let a31_2 = *datum_content.index(54);
528 let a31_3 = *datum_content.index(55);
529
530 let a32_0 = *datum_content.index(56);
531 let a32_1 = *datum_content.index(57);
532 let a32_2 = *datum_content.index(58);
533 let a32_3 = *datum_content.index(59);
534
535 let a33_0 = *datum_content.index(60);
536 let a33_1 = *datum_content.index(61);
537 let a33_2 = *datum_content.index(62);
538 let a33_3 = *datum_content.index(63);
539
540 let a00 = util::bits::u8_to_f32((a00_0, a00_1, a00_2, a00_3));
541 let a01 = util::bits::u8_to_f32((a01_0, a01_1, a01_2, a01_3));
542 let a02 = util::bits::u8_to_f32((a02_0, a02_1, a02_2, a02_3));
543 let a03 = util::bits::u8_to_f32((a03_0, a03_1, a03_2, a03_3));
544 let a10 = util::bits::u8_to_f32((a10_0, a10_1, a10_2, a10_3));
545 let a11 = util::bits::u8_to_f32((a11_0, a11_1, a11_2, a11_3));
546 let a12 = util::bits::u8_to_f32((a12_0, a12_1, a12_2, a12_3));
547 let a13 = util::bits::u8_to_f32((a13_0, a13_1, a13_2, a13_3));
548 let a20 = util::bits::u8_to_f32((a20_0, a20_1, a20_2, a20_3));
549 let a21 = util::bits::u8_to_f32((a21_0, a21_1, a21_2, a21_3));
550 let a22 = util::bits::u8_to_f32((a22_0, a22_1, a22_2, a22_3));
551 let a23 = util::bits::u8_to_f32((a23_0, a23_1, a23_2, a23_3));
552 let a30 = util::bits::u8_to_f32((a30_0, a30_1, a30_2, a30_3));
553 let a31 = util::bits::u8_to_f32((a31_0, a31_1, a31_2, a31_3));
554 let a32 = util::bits::u8_to_f32((a32_0, a32_1, a32_2, a32_3));
555 let a33 = util::bits::u8_to_f32((a33_0, a33_1, a33_2, a33_3));
556
557 LoadedGltfAccessorDatum::mat4_of(
558 a00, a01, a02, a03,
559 a10, a11, a12, a13,
560 a20, a21, a22, a23,
561 a30, a31, a32, a33
562 )
563 }
564 };
565 result.push(datum);
566 }
567
568 result
569 }
570}
571
572impl LoadedGltfAccessorDatum {
573 pub fn scalar_of(num: GltfPosNum) -> Self {
574 Self::Scalar(num)
575 }
576
577 pub fn vec2_of(
578 x: GltfPosNum,
579 y: GltfPosNum
580 ) -> Self {
581 let vec = Vector2::new(x, y);
582 Self::Vec2(vec)
583 }
584
585 pub fn vec3_of(
586 x: GltfPosNum,
587 y: GltfPosNum,
588 z: GltfPosNum
589 ) -> Self {
590 let vec = Vector3::new(x, y, z);
591 Self::Vec3(vec)
592 }
593
594 pub fn vec4_of(
595 x: GltfPosNum,
596 y: GltfPosNum,
597 z: GltfPosNum,
598 w: GltfPosNum
599 ) -> Self {
600 let vec = Vector4::new(x, y, z, w);
601 Self::Vec4(vec)
602 }
603
604 pub fn mat2_of(
605 a00: GltfPosNum, a01: GltfPosNum,
606 a10: GltfPosNum, a11: GltfPosNum,
607 ) -> Self {
608 let mat = Matrix2::new(
609 a00, a01,
610 a10, a11);
611 Self::Mat2(mat)
612 }
613
614 pub fn mat3_of(
615 a00: GltfPosNum, a01: GltfPosNum, a02: GltfPosNum,
616 a10: GltfPosNum, a11: GltfPosNum, a12: GltfPosNum,
617 a20: GltfPosNum, a21: GltfPosNum, a22: GltfPosNum
618 ) -> Self {
619 let mat = Matrix3::new(
620 a00, a01, a02,
621 a10, a11, a12,
622 a20, a21, a22);
623 Self::Mat3(mat)
624 }
625
626 pub fn mat4_of(
627 a00: GltfPosNum, a01: GltfPosNum, a02: GltfPosNum, a03: GltfPosNum,
628 a10: GltfPosNum, a11: GltfPosNum, a12: GltfPosNum, a13: GltfPosNum,
629 a20: GltfPosNum, a21: GltfPosNum, a22: GltfPosNum, a23: GltfPosNum,
630 a30: GltfPosNum, a31: GltfPosNum, a32: GltfPosNum, a33: GltfPosNum
631 ) -> Self {
632 let mat = Matrix4::new(
633 a00, a01, a02, a03,
634 a10, a11, a12, a13,
635 a20, a21, a22, a23,
636 a30, a31, a32, a33);
637 Self::Mat4(mat)
638 }
639
640 pub fn get_dimension(&self) -> usize {
641 match *self {
642 Self::Scalar(_) => 1,
643 Self::Vec2(_) => 2,
644 Self::Vec3(_) => 3,
645 Self::Vec4(_) => 4,
646 Self::Mat2(_) => 2,
647 Self::Mat3(_) => 3,
648 Self::Mat4(_) => 4
649 }
650 }
651}
652
653impl LoadedGltfImage {
654 pub fn new(gltf: &Arc<Mutex<LoadedGltf>>, index: usize, uri: String, data: Vec<u8>) -> Self {
655 Self {
656 gltf: Arc::clone(gltf),
657 index,
658 uri,
659 data
660 }
661 }
662
663 pub fn get_gltf(&self) -> Arc<Mutex<LoadedGltf>> {
664 Arc::clone(&self.gltf)
665 }
666
667 pub fn get_index(&self) -> usize {
668 self.index
669 }
670
671 pub fn get_uri(&self) -> &String {
672 &self.uri
673 }
674
675 pub fn get_data(&self) -> &Vec<u8> {
676 &self.data
677 }
678
679 pub fn get_data_ptr(&self) -> *const u8 {
680 self.data.as_ptr()
681 }
682}
683
684impl LoadedGltf {
685 pub fn new() -> Self {
686 Self {
687 buffers: Vec::new(),
688 buffer_views: Vec::new(),
689 accessors: Vec::new(),
690 images: Vec::new()
691 }
692 }
693
694 pub fn get_buffers(&self) -> &Vec<LoadedGltfBuffer> {
695 &self.buffers
696 }
697
698 pub fn get_buffers_mut(&mut self) -> &mut Vec<LoadedGltfBuffer> {
699 &mut self.buffers
700 }
701
702 pub fn get_buffer_views(&self) -> &Vec<LoadedGltfBufferView> {
703 &self.buffer_views
704 }
705
706 pub fn get_buffer_views_mut(&mut self) -> &mut Vec<LoadedGltfBufferView> {
707 &mut self.buffer_views
708 }
709
710 pub fn get_accessors(&self) -> &Vec<LoadedGltfAccessor> {
711 &self.accessors
712 }
713
714 pub fn get_accessors_mut(&mut self) -> &mut Vec<LoadedGltfAccessor> {
715 &mut self.accessors
716 }
717
718 pub fn get_images(&self) -> &Vec<LoadedGltfImage> {
719 &self.images
720 }
721
722 pub fn get_images_mut(&mut self) -> &mut Vec<LoadedGltfImage> {
723 &mut self.images
724 }
725}
726
727impl LoadedGltfWrapper {
728 pub fn new(gltf: LoadedGltf) -> Self {
729 Self {
730 gltf: Arc::new(Mutex::new(gltf))
731 }
732 }
733
734 pub fn get(&self) -> &Arc<Mutex<LoadedGltf>> {
735 &self.gltf
736 }
737}