webglFramework/Thirdparty/three.js-master/editor/js/Loader.js

   1 /**
   2  * @author mrdoob / http://mrdoob.com/
   3  */
   4
   5 var Loader = function ( editor ) {
   6
   7         var scope = this;
   8         var signals = editor.signals;
   9
  10         this.texturePath = '';
  11
  12         this.loadFile = function ( file ) {
  13
  14                 var filename = file.name;
  15                 var extension = filename.split( '.' ).pop().toLowerCase();
  16
  17                 var reader = new FileReader();
  18                 reader.addEventListener( 'progress', function ( event ) {
  19
  20                         var size = '(' + Math.floor( event.total / 1000 ).format() + ' KB)';
  21                         var progress = Math.floor( ( event.loaded / event.total ) * 100 ) + '%';
  22                         console.log( 'Loading', filename, size, progress );
  23
  24                 } );
  25
  26                 switch ( extension ) {
  27
  28                         case '3ds':
  29
  30                                 reader.addEventListener( 'load', function ( event ) {
  31
  32                                         var loader = new THREE.TDSLoader();
  33                                         var object = loader.parse( event.target.result );
  34
  35                                         editor.execute( new AddObjectCommand( object ) );
  36
  37                                 }, false );
  38                                 reader.readAsArrayBuffer( file );
  39
  40                                 break;
  41
  42                         case 'amf':
  43
  44                                 reader.addEventListener( 'load', function ( event ) {
  45
  46                                         var loader = new THREE.AMFLoader();
  47                                         var amfobject = loader.parse( event.target.result );
  48
  49                                         editor.execute( new AddObjectCommand( amfobject ) );
  50
  51                                 }, false );
  52                                 reader.readAsArrayBuffer( file );
  53
  54                                 break;
  55
  56                         case 'awd':
  57
  58                                 reader.addEventListener( 'load', function ( event ) {
  59
  60                                         var loader = new THREE.AWDLoader();
  61                                         var scene = loader.parse( event.target.result );
  62
  63                                         editor.execute( new SetSceneCommand( scene ) );
  64
  65                                 }, false );
  66                                 reader.readAsArrayBuffer( file );
  67
  68                                 break;
  69
  70                         case 'babylon':
  71
  72                                 reader.addEventListener( 'load', function ( event ) {
  73
  74                                         var contents = event.target.result;
  75                                         var json = JSON.parse( contents );
  76
  77                                         var loader = new THREE.BabylonLoader();
  78                                         var scene = loader.parse( json );
  79
  80                                         editor.execute( new SetSceneCommand( scene ) );
  81
  82                                 }, false );
  83                                 reader.readAsText( file );
  84
  85                                 break;
  86
  87                         case 'babylonmeshdata':
  88
  89                                 reader.addEventListener( 'load', function ( event ) {
  90
  91                                         var contents = event.target.result;
  92                                         var json = JSON.parse( contents );
  93
  94                                         var loader = new THREE.BabylonLoader();
  95
  96                                         var geometry = loader.parseGeometry( json );
  97                                         var material = new THREE.MeshStandardMaterial();
  98
  99                                         var mesh = new THREE.Mesh( geometry, material );
 100                                         mesh.name = filename;
 101
 102                                         editor.execute( new AddObjectCommand( mesh ) );
 103
 104                                 }, false );
 105                                 reader.readAsText( file );
 106
 107                                 break;
 108
 109                         case 'ctm':
 110
 111                                 reader.addEventListener( 'load', function ( event ) {
 112
 113                                         var data = new Uint8Array( event.target.result );
 114
 115                                         var stream = new CTM.Stream( data );
 116                                         stream.offset = 0;
 117
 118                                         var loader = new THREE.CTMLoader();
 119                                         loader.createModel( new CTM.File( stream ), function( geometry ) {
 120
 121                                                 geometry.sourceType = "ctm";
 122                                                 geometry.sourceFile = file.name;
 123
 124                                                 var material = new THREE.MeshStandardMaterial();
 125
 126                                                 var mesh = new THREE.Mesh( geometry, material );
 127                                                 mesh.name = filename;
 128
 129                                                 editor.execute( new AddObjectCommand( mesh ) );
 130
 131                                         } );
 132
 133                                 }, false );
 134                                 reader.readAsArrayBuffer( file );
 135
 136                                 break;
 137
 138                         case 'dae':
 139
 140                                 reader.addEventListener( 'load', function ( event ) {
 141
 142                                         var contents = event.target.result;
 143
 144                                         var loader = new THREE.ColladaLoader();
 145                                         var collada = loader.parse( contents );
 146
 147                                         collada.scene.name = filename;
 148
 149                                         editor.execute( new AddObjectCommand( collada.scene ) );
 150
 151                                 }, false );
 152                                 reader.readAsText( file );
 153
 154                                 break;
 155
 156                         case 'fbx':
 157
 158                                 reader.addEventListener( 'load', function ( event ) {
 159
 160                                         var contents = event.target.result;
 161
 162                                         var loader = new THREE.FBXLoader();
 163                                         var object = loader.parse( contents );
 164
 165                                         editor.execute( new AddObjectCommand( object ) );
 166
 167                                 }, false );
 168                                 reader.readAsArrayBuffer( file );
 169
 170                                 break;
 171
 172                         case 'glb':
 173                         case 'gltf':
 174
 175                                 reader.addEventListener( 'load', function ( event ) {
 176
 177                                         var contents = event.target.result;
 178
 179                                         var loader = new THREE.GLTFLoader();
 180                                         loader.parse( contents, '', function ( result ) {
 181
 182                                                 result.scene.name = filename;
 183                                                 editor.execute( new AddObjectCommand( result.scene ) );
 184
 185                                         } );
 186
 187                                 }, false );
 188                                 reader.readAsArrayBuffer( file );
 189
 190                                 break;
 191
 192                         case 'js':
 193                         case 'json':
 194
 195                         case '3geo':
 196                         case '3mat':
 197                         case '3obj':
 198                         case '3scn':
 199
 200                                 reader.addEventListener( 'load', function ( event ) {
 201
 202                                         var contents = event.target.result;
 203
 204                                         // 2.0
 205
 206                                         if ( contents.indexOf( 'postMessage' ) !== - 1 ) {
 207
 208                                                 var blob = new Blob( [ contents ], { type: 'text/javascript' } );
 209                                                 var url = URL.createObjectURL( blob );
 210
 211                                                 var worker = new Worker( url );
 212
 213                                                 worker.onmessage = function ( event ) {
 214
 215                                                         event.data.metadata = { version: 2 };
 216                                                         handleJSON( event.data, file, filename );
 217
 218                                                 };
 219
 220                                                 worker.postMessage( Date.now() );
 221
 222                                                 return;
 223
 224                                         }
 225
 226                                         // >= 3.0
 227
 228                                         var data;
 229
 230                                         try {
 231
 232                                                 data = JSON.parse( contents );
 233
 234                                         } catch ( error ) {
 235
 236                                                 alert( error );
 237                                                 return;
 238
 239                                         }
 240
 241                                         handleJSON( data, file, filename );
 242
 243                                 }, false );
 244                                 reader.readAsText( file );
 245
 246                                 break;
 247
 248
 249                         case 'kmz':
 250
 251                                 reader.addEventListener( 'load', function ( event ) {
 252
 253                                         var loader = new THREE.KMZLoader();
 254                                         var collada = loader.parse( event.target.result );
 255
 256                                         collada.scene.name = filename;
 257
 258                                         editor.execute( new AddObjectCommand( collada.scene ) );
 259
 260                                 }, false );
 261                                 reader.readAsArrayBuffer( file );
 262
 263                                 break;
 264
 265                         case 'md2':
 266
 267                                 reader.addEventListener( 'load', function ( event ) {
 268
 269                                         var contents = event.target.result;
 270
 271                                         var geometry = new THREE.MD2Loader().parse( contents );
 272                                         var material = new THREE.MeshStandardMaterial( {
 273                                                 morphTargets: true,
 274                                                 morphNormals: true
 275                                         } );
 276
 277                                         var mesh = new THREE.Mesh( geometry, material );
 278                                         mesh.mixer = new THREE.AnimationMixer( mesh );
 279                                         mesh.name = filename;
 280
 281                                         editor.execute( new AddObjectCommand( mesh ) );
 282
 283                                 }, false );
 284                                 reader.readAsArrayBuffer( file );
 285
 286                                 break;
 287
 288                         case 'obj':
 289
 290                                 reader.addEventListener( 'load', function ( event ) {
 291
 292                                         var contents = event.target.result;
 293
 294                                         var object = new THREE.OBJLoader().parse( contents );
 295                                         object.name = filename;
 296
 297                                         editor.execute( new AddObjectCommand( object ) );
 298
 299                                 }, false );
 300                                 reader.readAsText( file );
 301
 302                                 break;
 303
 304                         case 'playcanvas':
 305
 306                                 reader.addEventListener( 'load', function ( event ) {
 307
 308                                         var contents = event.target.result;
 309                                         var json = JSON.parse( contents );
 310
 311                                         var loader = new THREE.PlayCanvasLoader();
 312                                         var object = loader.parse( json );
 313
 314                                         editor.execute( new AddObjectCommand( object ) );
 315
 316                                 }, false );
 317                                 reader.readAsText( file );
 318
 319                                 break;
 320
 321                         case 'ply':
 322
 323                                 reader.addEventListener( 'load', function ( event ) {
 324
 325                                         var contents = event.target.result;
 326
 327                                         var geometry = new THREE.PLYLoader().parse( contents );
 328                                         geometry.sourceType = "ply";
 329                                         geometry.sourceFile = file.name;
 330
 331                                         var material = new THREE.MeshStandardMaterial();
 332
 333                                         var mesh = new THREE.Mesh( geometry, material );
 334                                         mesh.name = filename;
 335
 336                                         editor.execute( new AddObjectCommand( mesh ) );
 337
 338                                 }, false );
 339                                 reader.readAsArrayBuffer( file );
 340
 341                                 break;
 342
 343                         case 'stl':
 344
 345                                 reader.addEventListener( 'load', function ( event ) {
 346
 347                                         var contents = event.target.result;
 348
 349                                         var geometry = new THREE.STLLoader().parse( contents );
 350                                         geometry.sourceType = "stl";
 351                                         geometry.sourceFile = file.name;
 352
 353                                         var material = new THREE.MeshStandardMaterial();
 354
 355                                         var mesh = new THREE.Mesh( geometry, material );
 356                                         mesh.name = filename;
 357
 358                                         editor.execute( new AddObjectCommand( mesh ) );
 359
 360                                 }, false );
 361
 362                                 if ( reader.readAsBinaryString !== undefined ) {
 363
 364                                         reader.readAsBinaryString( file );
 365
 366                                 } else {
 367
 368                                         reader.readAsArrayBuffer( file );
 369
 370                                 }
 371
 372                                 break;
 373
 374                         /*
 375                         case 'utf8':
 376
 377                                 reader.addEventListener( 'load', function ( event ) {
 378
 379                                         var contents = event.target.result;
 380
 381                                         var geometry = new THREE.UTF8Loader().parse( contents );
 382                                         var material = new THREE.MeshLambertMaterial();
 383
 384                                         var mesh = new THREE.Mesh( geometry, material );
 385
 386                                         editor.execute( new AddObjectCommand( mesh ) );
 387
 388                                 }, false );
 389                                 reader.readAsBinaryString( file );
 390
 391                                 break;
 392                         */
 393
 394                         case 'vtk':
 395
 396                                 reader.addEventListener( 'load', function ( event ) {
 397
 398                                         var contents = event.target.result;
 399
 400                                         var geometry = new THREE.VTKLoader().parse( contents );
 401                                         geometry.sourceType = "vtk";
 402                                         geometry.sourceFile = file.name;
 403
 404                                         var material = new THREE.MeshStandardMaterial();
 405
 406                                         var mesh = new THREE.Mesh( geometry, material );
 407                                         mesh.name = filename;
 408
 409                                         editor.execute( new AddObjectCommand( mesh ) );
 410
 411                                 }, false );
 412                                 reader.readAsText( file );
 413
 414                                 break;
 415
 416                         case 'wrl':
 417
 418                                 reader.addEventListener( 'load', function ( event ) {
 419
 420                                         var contents = event.target.result;
 421
 422                                         var result = new THREE.VRMLLoader().parse( contents );
 423
 424                                         editor.execute( new SetSceneCommand( result ) );
 425
 426                                 }, false );
 427                                 reader.readAsText( file );
 428
 429                                 break;
 430
 431                         case 'zip':
 432
 433                                 reader.addEventListener( 'load', function ( event ) {
 434
 435                                         var contents = event.target.result;
 436
 437                                         var zip = new JSZip( contents );
 438
 439                                         // BLOCKS
 440
 441                                         if ( zip.files[ 'model.obj' ] && zip.files[ 'materials.mtl' ] ) {
 442
 443                                                 var materials = new THREE.MTLLoader().parse( zip.file( 'materials.mtl' ).asText() );
 444                                                 var object = new THREE.OBJLoader().setMaterials( materials ).parse( zip.file( 'model.obj' ).asText() );
 445                                                 editor.execute( new AddObjectCommand( object ) );
 446
 447                                         }
 448
 449                                 }, false );
 450                                 reader.readAsBinaryString( file );
 451
 452                                 break;
 453
 454                         default:
 455
 456                                 alert( 'Unsupported file format (' + extension +  ').' );
 457
 458                                 break;
 459
 460                 }
 461
 462         };
 463
 464         function handleJSON( data, file, filename ) {
 465
 466                 if ( data.metadata === undefined ) { // 2.0
 467
 468                         data.metadata = { type: 'Geometry' };
 469
 470                 }
 471
 472                 if ( data.metadata.type === undefined ) { // 3.0
 473
 474                         data.metadata.type = 'Geometry';
 475
 476                 }
 477
 478                 if ( data.metadata.formatVersion !== undefined ) {
 479
 480                         data.metadata.version = data.metadata.formatVersion;
 481
 482                 }
 483
 484                 switch ( data.metadata.type.toLowerCase() ) {
 485
 486                         case 'buffergeometry':
 487
 488                                 var loader = new THREE.BufferGeometryLoader();
 489                                 var result = loader.parse( data );
 490
 491                                 var mesh = new THREE.Mesh( result );
 492
 493                                 editor.execute( new AddObjectCommand( mesh ) );
 494
 495                                 break;
 496
 497                         case 'geometry':
 498
 499                                 var loader = new THREE.JSONLoader();
 500                                 loader.setTexturePath( scope.texturePath );
 501
 502                                 var result = loader.parse( data );
 503
 504                                 var geometry = result.geometry;
 505                                 var material;
 506
 507                                 if ( result.materials !== undefined ) {
 508
 509                                         if ( result.materials.length > 1 ) {
 510
 511                                                 material = new THREE.MultiMaterial( result.materials );
 512
 513                                         } else {
 514
 515                                                 material = result.materials[ 0 ];
 516
 517                                         }
 518
 519                                 } else {
 520
 521                                         material = new THREE.MeshStandardMaterial();
 522
 523                                 }
 524
 525                                 geometry.sourceType = "ascii";
 526                                 geometry.sourceFile = file.name;
 527
 528                                 var mesh;
 529
 530                                 if ( geometry.animation && geometry.animation.hierarchy ) {
 531
 532                                         mesh = new THREE.SkinnedMesh( geometry, material );
 533
 534                                 } else {
 535
 536                                         mesh = new THREE.Mesh( geometry, material );
 537
 538                                 }
 539
 540                                 mesh.name = filename;
 541
 542                                 editor.execute( new AddObjectCommand( mesh ) );
 543
 544                                 break;
 545
 546                         case 'object':
 547
 548                                 var loader = new THREE.ObjectLoader();
 549                                 loader.setTexturePath( scope.texturePath );
 550
 551                                 var result = loader.parse( data );
 552
 553                                 if ( result instanceof THREE.Scene ) {
 554
 555                                         editor.execute( new SetSceneCommand( result ) );
 556
 557                                 } else {
 558
 559                                         editor.execute( new AddObjectCommand( result ) );
 560
 561                                 }
 562
 563                                 break;
 564
 565                         case 'app':
 566
 567                                 editor.fromJSON( data );
 568
 569                                 break;
 570
 571                 }
 572
 573         }
 574
 575 };