@coda-console/resource-manager 0.8.1 → 0.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,992 @@
1
+ import {
2
+ BufferGeometry,
3
+ FileLoader,
4
+ BufferAttribute,
5
+ Float32BufferAttribute,
6
+ Int8BufferAttribute,
7
+ Int16BufferAttribute,
8
+ Int32BufferAttribute,
9
+ Loader,
10
+ Uint8BufferAttribute,
11
+ Uint16BufferAttribute,
12
+ Uint32BufferAttribute,
13
+ Color,
14
+ SRGBColorSpace
15
+ } from '../../build/three.module.mjs';
16
+
17
+ const _color = new Color();
18
+
19
+ /**
20
+ * A loader for PLY the PLY format (known as the Polygon
21
+ * File Format or the Stanford Triangle Format).
22
+ *
23
+ * Limitations:
24
+ * - ASCII decoding assumes file is UTF-8.
25
+ *
26
+ * ```js
27
+ * const loader = new PLYLoader();
28
+ * const geometry = await loader.loadAsync( './models/ply/ascii/dolphins.ply' );
29
+ * scene.add( new THREE.Mesh( geometry ) );
30
+ * ```
31
+ *
32
+ * @augments Loader
33
+ * @three_import import { PLYLoader } from 'three/addons/loaders/PLYLoader.js';
34
+ */
35
+ class PLYLoader extends Loader {
36
+
37
+ /**
38
+ * Constructs a new PLY loader.
39
+ *
40
+ * @param {LoadingManager} [manager] - The loading manager.
41
+ */
42
+ constructor( manager ) {
43
+
44
+ super( manager );
45
+
46
+ // internals
47
+
48
+ this.propertyNameMapping = {};
49
+ this.customPropertyMapping = {};
50
+
51
+ }
52
+
53
+ /**
54
+ * Starts loading from the given URL and passes the loaded PLY asset
55
+ * to the `onLoad()` callback.
56
+ *
57
+ * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
58
+ * @param {function(BufferGeometry)} onLoad - Executed when the loading process has been finished.
59
+ * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
60
+ * @param {onErrorCallback} onError - Executed when errors occur.
61
+ */
62
+ load( url, onLoad, onProgress, onError ) {
63
+
64
+ const scope = this;
65
+
66
+ const loader = new FileLoader( this.manager );
67
+ loader.setPriority( this.priority );
68
+ loader.setCache( this.cache );
69
+ loader.setPath( this.path );
70
+ loader.setResponseType( 'arraybuffer' );
71
+ loader.setRequestHeader( this.requestHeader );
72
+ loader.setWithCredentials( this.withCredentials );
73
+ loader.load( url, function ( text ) {
74
+
75
+ try {
76
+
77
+ onLoad( scope.parse( text ) );
78
+
79
+ } catch ( e ) {
80
+
81
+ if ( onError ) {
82
+
83
+ onError( e );
84
+
85
+ } else {
86
+
87
+ console.error( e );
88
+
89
+ }
90
+
91
+ scope.manager.itemError( url );
92
+
93
+ }
94
+
95
+ }, onProgress, onError );
96
+
97
+ }
98
+
99
+ /**
100
+ * Sets a property name mapping that maps default property names
101
+ * to custom ones. For example, the following maps the properties
102
+ * “diffuse_(red|green|blue)” in the file to standard color names.
103
+ *
104
+ * ```js
105
+ * loader.setPropertyNameMapping( {
106
+ * diffuse_red: 'red',
107
+ * diffuse_green: 'green',
108
+ * diffuse_blue: 'blue'
109
+ * } );
110
+ * ```
111
+ *
112
+ * @param {Object} mapping - The mapping dictionary.
113
+ */
114
+ setPropertyNameMapping( mapping ) {
115
+
116
+ this.propertyNameMapping = mapping;
117
+
118
+ }
119
+
120
+ /**
121
+ * Custom properties outside of the defaults for position, uv, normal
122
+ * and color attributes can be added using the setCustomPropertyNameMapping method.
123
+ * For example, the following maps the element properties “custom_property_a”
124
+ * and “custom_property_b” to an attribute “customAttribute” with an item size of 2.
125
+ * Attribute item sizes are set from the number of element properties in the property array.
126
+ *
127
+ * ```js
128
+ * loader.setCustomPropertyNameMapping( {
129
+ * customAttribute: ['custom_property_a', 'custom_property_b'],
130
+ * } );
131
+ * ```
132
+ * @param {Object} mapping - The mapping dictionary.
133
+ */
134
+ setCustomPropertyNameMapping( mapping ) {
135
+
136
+ this.customPropertyMapping = mapping;
137
+
138
+ }
139
+
140
+ /**
141
+ * Parses the given PLY data and returns the resulting geometry.
142
+ *
143
+ * @param {ArrayBuffer} data - The raw PLY data as an array buffer.
144
+ * @return {BufferGeometry} The parsed geometry.
145
+ */
146
+ parse( data ) {
147
+
148
+ function parseHeader( data, headerLength = 0 ) {
149
+
150
+ const patternHeader = /^ply([\s\S]*)end_header(\r\n|\r|\n)/;
151
+ let headerText = '';
152
+ const result = patternHeader.exec( data );
153
+
154
+ if ( result !== null ) {
155
+
156
+ headerText = result[ 1 ];
157
+
158
+ }
159
+
160
+ const header = {
161
+ comments: [],
162
+ elements: [],
163
+ headerLength: headerLength,
164
+ objInfo: ''
165
+ };
166
+
167
+ const lines = headerText.split( /\r\n|\r|\n/ );
168
+ let currentElement;
169
+
170
+ function make_ply_element_property( propertyValues, propertyNameMapping ) {
171
+
172
+ const property = { type: propertyValues[ 0 ] };
173
+
174
+ if ( property.type === 'list' ) {
175
+
176
+ property.name = propertyValues[ 3 ];
177
+ property.countType = propertyValues[ 1 ];
178
+ property.itemType = propertyValues[ 2 ];
179
+
180
+ } else {
181
+
182
+ property.name = propertyValues[ 1 ];
183
+
184
+ }
185
+
186
+ if ( property.name in propertyNameMapping ) {
187
+
188
+ property.name = propertyNameMapping[ property.name ];
189
+
190
+ }
191
+
192
+ return property;
193
+
194
+ }
195
+
196
+ for ( let i = 0; i < lines.length; i ++ ) {
197
+
198
+ let line = lines[ i ];
199
+ line = line.trim();
200
+
201
+ if ( line === '' ) continue;
202
+
203
+ const lineValues = line.split( /\s+/ );
204
+ const lineType = lineValues.shift();
205
+ line = lineValues.join( ' ' );
206
+
207
+ switch ( lineType ) {
208
+
209
+ case 'format':
210
+
211
+ header.format = lineValues[ 0 ];
212
+ header.version = lineValues[ 1 ];
213
+
214
+ break;
215
+
216
+ case 'comment':
217
+
218
+ header.comments.push( line );
219
+
220
+ break;
221
+
222
+ case 'element':
223
+
224
+ if ( currentElement !== undefined ) {
225
+
226
+ header.elements.push( currentElement );
227
+
228
+ }
229
+
230
+ currentElement = {};
231
+ currentElement.name = lineValues[ 0 ];
232
+ currentElement.count = parseInt( lineValues[ 1 ] );
233
+ currentElement.properties = [];
234
+
235
+ break;
236
+
237
+ case 'property':
238
+
239
+ currentElement.properties.push( make_ply_element_property( lineValues, scope.propertyNameMapping ) );
240
+
241
+ break;
242
+
243
+ case 'obj_info':
244
+
245
+ header.objInfo = line;
246
+
247
+ break;
248
+
249
+
250
+ default:
251
+
252
+ console.log( 'unhandled', lineType, lineValues );
253
+
254
+ }
255
+
256
+ }
257
+
258
+ if ( currentElement !== undefined ) {
259
+
260
+ header.elements.push( currentElement );
261
+
262
+ }
263
+
264
+ return header;
265
+
266
+ }
267
+
268
+ function parseASCIINumber( n, type ) {
269
+
270
+ switch ( type ) {
271
+
272
+ case 'char': case 'uchar': case 'short': case 'ushort': case 'int': case 'uint':
273
+ case 'int8': case 'uint8': case 'int16': case 'uint16': case 'int32': case 'uint32':
274
+
275
+ return parseInt( n );
276
+
277
+ case 'float': case 'double': case 'float32': case 'float64':
278
+
279
+ return parseFloat( n );
280
+
281
+ }
282
+
283
+ }
284
+
285
+ function parseASCIIElement( properties, tokens ) {
286
+
287
+ const element = {};
288
+
289
+ for ( let i = 0; i < properties.length; i ++ ) {
290
+
291
+ if ( tokens.empty() ) return null;
292
+
293
+ if ( properties[ i ].type === 'list' ) {
294
+
295
+ const list = [];
296
+ const n = parseASCIINumber( tokens.next(), properties[ i ].countType );
297
+
298
+ for ( let j = 0; j < n; j ++ ) {
299
+
300
+ if ( tokens.empty() ) return null;
301
+
302
+ list.push( parseASCIINumber( tokens.next(), properties[ i ].itemType ) );
303
+
304
+ }
305
+
306
+ element[ properties[ i ].name ] = list;
307
+
308
+ } else {
309
+
310
+ element[ properties[ i ].name ] = parseASCIINumber( tokens.next(), properties[ i ].type );
311
+
312
+ }
313
+
314
+ }
315
+
316
+ return element;
317
+
318
+ }
319
+
320
+ function createBuffer() {
321
+
322
+ const buffer = {
323
+ indices: [],
324
+ vertices: [],
325
+ normals: [],
326
+ uvs: [],
327
+ faceVertexUvs: [],
328
+ colors: [],
329
+ faceVertexColors: [],
330
+ descriptors: {}
331
+ };
332
+
333
+ for ( const customProperty of Object.keys( scope.customPropertyMapping ) ) {
334
+
335
+ buffer[ customProperty ] = [];
336
+
337
+ }
338
+
339
+ return buffer;
340
+
341
+ }
342
+
343
+
344
+ function getBufferAttributeClass( type ) {
345
+
346
+ switch ( type ) {
347
+
348
+ case 'int8': case 'char': return Int8BufferAttribute;
349
+ case 'uint8': case 'uchar': return Uint8BufferAttribute;
350
+ case 'int16': case 'short': return Int16BufferAttribute;
351
+ case 'uint16': case 'ushort': return Uint16BufferAttribute;
352
+ case 'int32': case 'int': return Int32BufferAttribute;
353
+ case 'uint32': case 'uint': return Uint32BufferAttribute;
354
+ case 'float32': case 'float': return Float32BufferAttribute;
355
+ case 'float64': case 'double': return Float64BufferAttribute;
356
+
357
+ }
358
+
359
+ }
360
+
361
+ function getColorScale( type ) {
362
+
363
+ switch ( type ) {
364
+
365
+ case 'uchar': case 'uint8': return 1 / 255;
366
+ case 'ushort': case 'uint16': return 1 / 65535;
367
+ case 'float': case 'float32':
368
+ case 'double': case 'float64': return 1;
369
+ default: return 1 / 255;
370
+
371
+ }
372
+
373
+ }
374
+
375
+ function isFloatType( type ) {
376
+
377
+ return type === 'float' || type === 'float32' || type === 'double' || type === 'float64';
378
+
379
+ }
380
+
381
+ function getAttributeDescriptor( properties ) {
382
+
383
+ function findProperty( names ) {
384
+
385
+ for ( const name of names ) {
386
+
387
+ const property = properties.find( p => p.name === name );
388
+ if ( property ) return property;
389
+
390
+ }
391
+
392
+ return null;
393
+
394
+ }
395
+
396
+ // property lookup
397
+
398
+ const x = findProperty( [ 'x', 'px', 'posx' ] );
399
+ const y = findProperty( [ 'y', 'py', 'posy' ] );
400
+ const z = findProperty( [ 'z', 'pz', 'posz' ] );
401
+ const nx = findProperty( [ 'nx', 'normalx' ] );
402
+ const ny = findProperty( [ 'ny', 'normaly' ] );
403
+ const nz = findProperty( [ 'nz', 'normalz' ] );
404
+ const s = findProperty( [ 's', 'u', 'texture_u', 'tx' ] );
405
+ const t = findProperty( [ 't', 'v', 'texture_v', 'ty' ] );
406
+ const r = findProperty( [ 'red', 'diffuse_red', 'r', 'diffuse_r' ] );
407
+ const g = findProperty( [ 'green', 'diffuse_green', 'g', 'diffuse_g' ] );
408
+ const b = findProperty( [ 'blue', 'diffuse_blue', 'b', 'diffuse_b' ] );
409
+ const texcoord = findProperty( [ 'texcoord' ] );
410
+
411
+ // custom property lookup
412
+
413
+ const custom = {};
414
+
415
+ for ( const customAttr of Object.keys( scope.customPropertyMapping ) ) {
416
+
417
+ const propNames = scope.customPropertyMapping[ customAttr ];
418
+ const matched = propNames.map( name => properties.find( p => p.name === name ) );
419
+ const types = matched.filter( p => p ).map( p => p.type );
420
+ const uniform = types.length > 0 && types.every( type => type === types[ 0 ] );
421
+
422
+ custom[ customAttr ] = {
423
+ type: uniform ? types[ 0 ] : 'float32',
424
+ usage: matched.every( p => p !== undefined ),
425
+ };
426
+
427
+ }
428
+
429
+ // build descriptor
430
+
431
+ return {
432
+ position: {
433
+ names: [ x ? x.name : 'x', y ? y.name : 'y', z ? z.name : 'z' ],
434
+ type: x ? x.type : 'float32',
435
+ usage: !! ( x && y && z ),
436
+ },
437
+ normal: {
438
+ names: [ nx ? nx.name : 'nx', ny ? ny.name : 'ny', nz ? nz.name : 'nz' ],
439
+ type: nx ? nx.type : 'float32',
440
+ usage: !! ( nx && ny && nz ),
441
+ },
442
+ uv: {
443
+ names: [ s ? s.name : 's', t ? t.name : 't' ],
444
+ type: s ? s.type : 'float32',
445
+ usage: !! ( s && t ),
446
+ },
447
+ texcoord: {
448
+ type: texcoord ? texcoord.itemType : 'float32',
449
+ usage: !! texcoord,
450
+ },
451
+ color: {
452
+ names: [ r ? r.name : 'red', g ? g.name : 'green', b ? b.name : 'blue' ],
453
+ type: r ? r.type : 'uchar',
454
+ usage: !! ( r && g && b ),
455
+ },
456
+ custom: custom,
457
+ };
458
+
459
+ }
460
+
461
+ function parseASCII( data, header ) {
462
+
463
+ // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
464
+
465
+ const buffer = createBuffer();
466
+
467
+ const patternBody = /end_header\s+(\S[\s\S]*\S|\S)\s*$/;
468
+ let body, matches;
469
+
470
+ if ( ( matches = patternBody.exec( data ) ) !== null ) {
471
+
472
+ body = matches[ 1 ].split( /\s+/ );
473
+
474
+ } else {
475
+
476
+ body = [ ];
477
+
478
+ }
479
+
480
+ const tokens = new ArrayStream( body );
481
+
482
+ loop: for ( let i = 0; i < header.elements.length; i ++ ) {
483
+
484
+ const elementDesc = header.elements[ i ];
485
+ const attributeDescriptor = getAttributeDescriptor( elementDesc.properties );
486
+ buffer.descriptors[ elementDesc.name ] = attributeDescriptor;
487
+
488
+ for ( let j = 0; j < elementDesc.count; j ++ ) {
489
+
490
+ const element = parseASCIIElement( elementDesc.properties, tokens );
491
+
492
+ if ( ! element ) break loop;
493
+
494
+ handleElement( buffer, elementDesc.name, element, attributeDescriptor );
495
+
496
+ }
497
+
498
+ }
499
+
500
+ return postProcess( buffer );
501
+
502
+ }
503
+
504
+ function postProcess( buffer ) {
505
+
506
+ let geometry = new BufferGeometry();
507
+
508
+ const vertexDescriptor = buffer.descriptors.vertex;
509
+
510
+ // mandatory buffer data
511
+
512
+ if ( buffer.indices.length > 0 ) {
513
+
514
+ geometry.setIndex( buffer.indices );
515
+
516
+ }
517
+
518
+ const PositionClass = getBufferAttributeClass( vertexDescriptor ? vertexDescriptor.position.type : 'float32' );
519
+ geometry.setAttribute( 'position', new PositionClass( buffer.vertices, 3 ) );
520
+
521
+ // optional buffer data
522
+
523
+ if ( buffer.normals.length > 0 ) {
524
+
525
+ const NormalClass = getBufferAttributeClass( vertexDescriptor.normal.type );
526
+ geometry.setAttribute( 'normal', new NormalClass( buffer.normals, 3 ) );
527
+
528
+ }
529
+
530
+ if ( buffer.uvs.length > 0 ) {
531
+
532
+ const UvClass = getBufferAttributeClass( vertexDescriptor.uv.type );
533
+ geometry.setAttribute( 'uv', new UvClass( buffer.uvs, 2 ) );
534
+
535
+ }
536
+
537
+ if ( buffer.colors.length > 0 ) {
538
+
539
+ const colorType = vertexDescriptor.color.type;
540
+ const normalized = ! isFloatType( colorType );
541
+
542
+ const ColorClass = getBufferAttributeClass( colorType );
543
+ geometry.setAttribute( 'color', new ColorClass( buffer.colors, 3, normalized ) );
544
+
545
+ }
546
+
547
+ // custom buffer data
548
+
549
+ for ( const customProperty of Object.keys( scope.customPropertyMapping ) ) {
550
+
551
+ if ( buffer[ customProperty ].length > 0 ) {
552
+
553
+ const CustomClass = getBufferAttributeClass( vertexDescriptor.custom[ customProperty ].type );
554
+ geometry.setAttribute( customProperty, new CustomClass( buffer[ customProperty ], scope.customPropertyMapping[ customProperty ].length ) );
555
+
556
+ }
557
+
558
+ }
559
+
560
+ if ( buffer.faceVertexUvs.length > 0 || buffer.faceVertexColors.length > 0 ) {
561
+
562
+ geometry = geometry.toNonIndexed();
563
+
564
+ if ( buffer.faceVertexUvs.length > 0 ) {
565
+
566
+ const UvClass = getBufferAttributeClass( buffer.descriptors.face.texcoord.type );
567
+ geometry.setAttribute( 'uv', new UvClass( buffer.faceVertexUvs, 2 ) );
568
+
569
+ }
570
+
571
+ if ( buffer.faceVertexColors.length > 0 ) {
572
+
573
+ const colorType = buffer.descriptors.face.color.type;
574
+ const normalized = ! isFloatType( colorType );
575
+
576
+ const ColorClass = getBufferAttributeClass( colorType );
577
+ geometry.setAttribute( 'color', new ColorClass( buffer.faceVertexColors, 3, normalized ) );
578
+
579
+ }
580
+
581
+ }
582
+
583
+ geometry.computeBoundingSphere();
584
+
585
+ return geometry;
586
+
587
+ }
588
+
589
+ function handleElement( buffer, elementName, element, attributeDescriptor ) {
590
+
591
+ if ( elementName === 'vertex' ) {
592
+
593
+ const { position, normal, uv, color } = attributeDescriptor;
594
+
595
+ if ( position.usage ) {
596
+
597
+ buffer.vertices.push(
598
+ element[ position.names[ 0 ] ],
599
+ element[ position.names[ 1 ] ],
600
+ element[ position.names[ 2 ] ]
601
+ );
602
+
603
+ }
604
+
605
+ if ( normal.usage ) {
606
+
607
+ buffer.normals.push(
608
+ element[ normal.names[ 0 ] ],
609
+ element[ normal.names[ 1 ] ],
610
+ element[ normal.names[ 2 ] ]
611
+ );
612
+
613
+ }
614
+
615
+ if ( uv.usage ) {
616
+
617
+ buffer.uvs.push(
618
+ element[ uv.names[ 0 ] ],
619
+ element[ uv.names[ 1 ] ]
620
+ );
621
+
622
+ }
623
+
624
+ if ( color.usage ) {
625
+
626
+ const scale = getColorScale( color.type );
627
+ const isFloat = isFloatType( color.type );
628
+
629
+ // convert to float for color space conversion
630
+
631
+ _color.setRGB(
632
+ element[ color.names[ 0 ] ] * scale,
633
+ element[ color.names[ 1 ] ] * scale,
634
+ element[ color.names[ 2 ] ] * scale,
635
+ SRGBColorSpace
636
+ );
637
+
638
+ // convert back to original type
639
+
640
+ const invScale = 1 / scale;
641
+
642
+ buffer.colors.push(
643
+ isFloat ? _color.r : Math.round( _color.r * invScale ),
644
+ isFloat ? _color.g : Math.round( _color.g * invScale ),
645
+ isFloat ? _color.b : Math.round( _color.b * invScale )
646
+ );
647
+
648
+ }
649
+
650
+ for ( const customProperty of Object.keys( scope.customPropertyMapping ) ) {
651
+
652
+ for ( const elementProperty of scope.customPropertyMapping[ customProperty ] ) {
653
+
654
+ buffer[ customProperty ].push( element[ elementProperty ] );
655
+
656
+ }
657
+
658
+ }
659
+
660
+ } else if ( elementName === 'face' ) {
661
+
662
+ const vertex_indices = element.vertex_indices || element.vertex_index; // issue #9338
663
+ const texcoord = element.texcoord;
664
+
665
+ if ( vertex_indices.length === 3 ) {
666
+
667
+ buffer.indices.push( vertex_indices[ 0 ], vertex_indices[ 1 ], vertex_indices[ 2 ] );
668
+
669
+ if ( texcoord && texcoord.length === 6 ) {
670
+
671
+ buffer.faceVertexUvs.push( texcoord[ 0 ], texcoord[ 1 ] );
672
+ buffer.faceVertexUvs.push( texcoord[ 2 ], texcoord[ 3 ] );
673
+ buffer.faceVertexUvs.push( texcoord[ 4 ], texcoord[ 5 ] );
674
+
675
+ }
676
+
677
+ } else if ( vertex_indices.length === 4 ) {
678
+
679
+ // according to the spec, quads need to be split along a specific rule
680
+ // 4 0 1 2 3 results in 0,1,2 and 0,2,3
681
+
682
+ buffer.indices.push( vertex_indices[ 0 ], vertex_indices[ 1 ], vertex_indices[ 2 ] );
683
+ buffer.indices.push( vertex_indices[ 0 ], vertex_indices[ 2 ], vertex_indices[ 3 ] );
684
+
685
+ if ( texcoord && texcoord.length === 8 ) {
686
+
687
+ buffer.faceVertexUvs.push( texcoord[ 0 ], texcoord[ 1 ] );
688
+ buffer.faceVertexUvs.push( texcoord[ 2 ], texcoord[ 3 ] );
689
+ buffer.faceVertexUvs.push( texcoord[ 4 ], texcoord[ 5 ] );
690
+ buffer.faceVertexUvs.push( texcoord[ 0 ], texcoord[ 1 ] );
691
+ buffer.faceVertexUvs.push( texcoord[ 4 ], texcoord[ 5 ] );
692
+ buffer.faceVertexUvs.push( texcoord[ 6 ], texcoord[ 7 ] );
693
+
694
+ }
695
+
696
+ }
697
+
698
+ // face colors
699
+
700
+ const { color } = attributeDescriptor;
701
+
702
+ if ( color.usage ) {
703
+
704
+ // convert to float for color space conversion
705
+
706
+ const scale = getColorScale( color.type );
707
+
708
+ _color.setRGB(
709
+ element[ color.names[ 0 ] ] * scale,
710
+ element[ color.names[ 1 ] ] * scale,
711
+ element[ color.names[ 2 ] ] * scale,
712
+ SRGBColorSpace
713
+ );
714
+
715
+ // convert back to original type
716
+
717
+ const invScale = 1 / scale;
718
+
719
+ const r = _color.r * invScale;
720
+ const g = _color.g * invScale;
721
+ const b = _color.b * invScale;
722
+
723
+ buffer.faceVertexColors.push( r, g, b );
724
+ buffer.faceVertexColors.push( r, g, b );
725
+ buffer.faceVertexColors.push( r, g, b );
726
+
727
+ if ( vertex_indices.length === 4 ) {
728
+
729
+ buffer.faceVertexColors.push( r, g, b );
730
+ buffer.faceVertexColors.push( r, g, b );
731
+ buffer.faceVertexColors.push( r, g, b );
732
+
733
+ }
734
+
735
+ }
736
+
737
+ }
738
+
739
+ }
740
+
741
+ function binaryReadElement( at, properties ) {
742
+
743
+ const element = {};
744
+ let read = 0;
745
+
746
+ for ( let i = 0; i < properties.length; i ++ ) {
747
+
748
+ const property = properties[ i ];
749
+ const valueReader = property.valueReader;
750
+
751
+ if ( property.type === 'list' ) {
752
+
753
+ const list = [];
754
+
755
+ const n = property.countReader.read( at + read );
756
+ read += property.countReader.size;
757
+
758
+ for ( let j = 0; j < n; j ++ ) {
759
+
760
+ list.push( valueReader.read( at + read ) );
761
+ read += valueReader.size;
762
+
763
+ }
764
+
765
+ element[ property.name ] = list;
766
+
767
+ } else {
768
+
769
+ element[ property.name ] = valueReader.read( at + read );
770
+ read += valueReader.size;
771
+
772
+ }
773
+
774
+ }
775
+
776
+ return [ element, read ];
777
+
778
+ }
779
+
780
+ function setPropertyBinaryReaders( properties, body, little_endian ) {
781
+
782
+ function getBinaryReader( dataview, type, little_endian ) {
783
+
784
+ switch ( type ) {
785
+
786
+ // correspondences for non-specific length types here match rply:
787
+ case 'int8': case 'char': return { read: ( at ) => {
788
+
789
+ return dataview.getInt8( at );
790
+
791
+ }, size: 1 };
792
+ case 'uint8': case 'uchar': return { read: ( at ) => {
793
+
794
+ return dataview.getUint8( at );
795
+
796
+ }, size: 1 };
797
+ case 'int16': case 'short': return { read: ( at ) => {
798
+
799
+ return dataview.getInt16( at, little_endian );
800
+
801
+ }, size: 2 };
802
+ case 'uint16': case 'ushort': return { read: ( at ) => {
803
+
804
+ return dataview.getUint16( at, little_endian );
805
+
806
+ }, size: 2 };
807
+ case 'int32': case 'int': return { read: ( at ) => {
808
+
809
+ return dataview.getInt32( at, little_endian );
810
+
811
+ }, size: 4 };
812
+ case 'uint32': case 'uint': return { read: ( at ) => {
813
+
814
+ return dataview.getUint32( at, little_endian );
815
+
816
+ }, size: 4 };
817
+ case 'float32': case 'float': return { read: ( at ) => {
818
+
819
+ return dataview.getFloat32( at, little_endian );
820
+
821
+ }, size: 4 };
822
+ case 'float64': case 'double': return { read: ( at ) => {
823
+
824
+ return dataview.getFloat64( at, little_endian );
825
+
826
+ }, size: 8 };
827
+
828
+ }
829
+
830
+ }
831
+
832
+ for ( let i = 0, l = properties.length; i < l; i ++ ) {
833
+
834
+ const property = properties[ i ];
835
+
836
+ if ( property.type === 'list' ) {
837
+
838
+ property.countReader = getBinaryReader( body, property.countType, little_endian );
839
+ property.valueReader = getBinaryReader( body, property.itemType, little_endian );
840
+
841
+ } else {
842
+
843
+ property.valueReader = getBinaryReader( body, property.type, little_endian );
844
+
845
+ }
846
+
847
+ }
848
+
849
+ }
850
+
851
+ function parseBinary( data, header ) {
852
+
853
+ const buffer = createBuffer();
854
+
855
+ const little_endian = ( header.format === 'binary_little_endian' );
856
+ const body = new DataView( data, header.headerLength );
857
+ let result, loc = 0;
858
+
859
+ for ( let currentElement = 0; currentElement < header.elements.length; currentElement ++ ) {
860
+
861
+ const elementDesc = header.elements[ currentElement ];
862
+ const properties = elementDesc.properties;
863
+ const attributeDescriptor = getAttributeDescriptor( properties );
864
+ buffer.descriptors[ elementDesc.name ] = attributeDescriptor;
865
+
866
+ setPropertyBinaryReaders( properties, body, little_endian );
867
+
868
+ for ( let currentElementCount = 0; currentElementCount < elementDesc.count; currentElementCount ++ ) {
869
+
870
+ result = binaryReadElement( loc, properties );
871
+ loc += result[ 1 ];
872
+ const element = result[ 0 ];
873
+
874
+ handleElement( buffer, elementDesc.name, element, attributeDescriptor );
875
+
876
+ }
877
+
878
+ }
879
+
880
+ return postProcess( buffer );
881
+
882
+ }
883
+
884
+ function extractHeaderText( bytes ) {
885
+
886
+ let i = 0;
887
+ let cont = true;
888
+
889
+ let line = '';
890
+ const lines = [];
891
+
892
+ const startLine = new TextDecoder().decode( bytes.subarray( 0, 5 ) );
893
+ const hasCRNL = /^ply\r\n/.test( startLine );
894
+
895
+ do {
896
+
897
+ const c = String.fromCharCode( bytes[ i ++ ] );
898
+
899
+ if ( c !== '\n' && c !== '\r' ) {
900
+
901
+ line += c;
902
+
903
+ } else {
904
+
905
+ if ( line === 'end_header' ) cont = false;
906
+ if ( line !== '' ) {
907
+
908
+ lines.push( line );
909
+ line = '';
910
+
911
+ }
912
+
913
+ }
914
+
915
+ } while ( cont && i < bytes.length );
916
+
917
+ // ascii section using \r\n as line endings
918
+ if ( hasCRNL === true ) i ++;
919
+
920
+ return { headerText: lines.join( '\r' ) + '\r', headerLength: i };
921
+
922
+ }
923
+
924
+ //
925
+
926
+ let geometry;
927
+ const scope = this;
928
+
929
+ if ( data instanceof ArrayBuffer ) {
930
+
931
+ const bytes = new Uint8Array( data );
932
+ const { headerText, headerLength } = extractHeaderText( bytes );
933
+ const header = parseHeader( headerText, headerLength );
934
+
935
+ if ( header.format === 'ascii' ) {
936
+
937
+ const text = new TextDecoder().decode( bytes );
938
+
939
+ geometry = parseASCII( text, header );
940
+
941
+ } else {
942
+
943
+ geometry = parseBinary( data, header );
944
+
945
+ }
946
+
947
+ } else {
948
+
949
+ geometry = parseASCII( data, parseHeader( data ) );
950
+
951
+ }
952
+
953
+ return geometry;
954
+
955
+ }
956
+
957
+ }
958
+
959
+ class Float64BufferAttribute extends BufferAttribute {
960
+
961
+ constructor( array, itemSize, normalized ) {
962
+
963
+ super( new Float64Array( array ), itemSize, normalized );
964
+
965
+ }
966
+
967
+ }
968
+
969
+ class ArrayStream {
970
+
971
+ constructor( arr ) {
972
+
973
+ this.arr = arr;
974
+ this.i = 0;
975
+
976
+ }
977
+
978
+ empty() {
979
+
980
+ return this.i >= this.arr.length;
981
+
982
+ }
983
+
984
+ next() {
985
+
986
+ return this.arr[ this.i ++ ];
987
+
988
+ }
989
+
990
+ }
991
+
992
+ export { PLYLoader };