three-stdlib 2.22.9 → 2.23.0

package/dist/loaders/lwo/IFFParser.mjs

@@ -1,12 +1,10 @@
-import { LoaderUtils } from "three";
 import { LWO2Parser } from "./LWO2Parser.mjs";
 import { LWO3Parser } from "./LWO3Parser.mjs";
-function IFFParser() {
-  this.debugger = new Debugger();
-}
-IFFParser.prototype = {
-  constructor: IFFParser,
-  parse: function(buffer) {
+class IFFParser {
+  constructor() {
+    this.debugger = new Debugger();
+  }
+  parse(buffer) {
     this.reader = new DataViewReader(buffer);
     this.tree = {
       materials: {},
@@ -31,7 +29,7 @@ IFFParser.prototype = {
     this.debugger.offset = this.reader.offset;
     this.debugger.closeForms();
     return this.tree;
-  },
+  }
   parseTopForm() {
     this.debugger.offset = this.reader.offset;
     var topForm = this.reader.getIDTag();
@@ -52,7 +50,7 @@ IFFParser.prototype = {
     this.debugger.nodeID = type;
     this.debugger.log();
     return;
-  },
+  }
   ///
   // FORM PARSING METHODS
   ///
@@ -183,7 +181,7 @@ IFFParser.prototype = {
     this.debugger.node = 0;
     this.debugger.nodeID = type;
     this.debugger.log();
-  },
+  }
   setupForm(type, length) {
     if (!this.currentForm)
       this.currentForm = this.currentNode;
@@ -196,15 +194,15 @@ IFFParser.prototype = {
       console.warn("LWOLoader: form already exists on parent: ", type, this.currentForm);
       this.currentForm = this.currentForm[type];
     }
-  },
+  }
   skipForm(length) {
     this.reader.skip(length - 4);
-  },
+  }
   parseUnknownForm(type, length) {
     console.warn("LWOLoader: unknown FORM encountered: " + type, length);
     printBuffer(this.reader.dv.buffer, this.reader.offset, length - 4);
     this.reader.skip(length - 4);
-  },
+  }
   parseSurfaceForm(length) {
     this.reader.skip(8);
     var name = this.reader.getString();
@@ -222,7 +220,7 @@ IFFParser.prototype = {
     this.parentForm = this.tree.materials;
     this.currentForm = surface;
     this.currentFormEnd = this.reader.offset + length;
-  },
+  }
   parseSurfaceLwo2(length) {
     var name = this.reader.getString();
     var surface = {
@@ -238,7 +236,7 @@ IFFParser.prototype = {
     this.parentForm = this.tree.materials;
     this.currentForm = surface;
     this.currentFormEnd = this.reader.offset + length;
-  },
+  }
   parseSubNode(length) {
     this.reader.skip(8);
     var name = this.reader.getString();
@@ -248,20 +246,20 @@ IFFParser.prototype = {
     this.currentForm = node;
     this.currentNode = node;
     this.currentFormEnd = this.reader.offset + length;
-  },
+  }
   // collect attributes from all nodes at the top level of a surface
   parseConnections(length) {
     this.currentFormEnd = this.reader.offset + length;
     this.parentForm = this.currentForm;
     this.currentForm = this.currentSurface.connections;
-  },
+  }
   // surface node attribute data, e.g. specular, roughness etc
   parseEntryForm(length) {
     this.reader.skip(8);
     var name = this.reader.getString();
     this.currentForm = this.currentNode.attributes;
     this.setupForm(name, length);
-  },
+  }
   // parse values from material - doesn't match up to other LWO3 data types
   // sub form of entry form
   parseValueForm() {
@@ -278,13 +276,13 @@ IFFParser.prototype = {
       this.reader.skip(24);
       this.currentForm.value = this.reader.getFloat64Array(3);
     }
-  },
+  }
   // holds various data about texture node image state
   // Data other thanmipMapLevel unknown
   parseImageStateForm() {
     this.reader.skip(8);
     this.currentForm.mipMapLevel = this.reader.getFloat32();
-  },
+  }
   // LWO2 style image data node OR LWO3 textures defined at top level in editor (not as SURF node)
   parseImageMap(length) {
     this.currentFormEnd = this.reader.offset + length;
@@ -295,7 +293,7 @@ IFFParser.prototype = {
     this.currentForm.maps.push(map);
     this.currentForm = map;
     this.reader.skip(10);
-  },
+  }
   parseTextureNodeAttribute(type) {
     this.reader.skip(28);
     this.reader.skip(20);
@@ -323,11 +321,11 @@ IFFParser.prototype = {
         break;
     }
     this.reader.skip(2);
-  },
+  }
   // ENVL forms are currently ignored
   parseEnvelope(length) {
     this.reader.skip(length - 4);
-  },
+  }
   ///
   // CHUNK PARSING METHODS
   ///
@@ -349,7 +347,7 @@ IFFParser.prototype = {
     };
     this.tree.textures.push(texture);
     this.currentForm = texture;
-  },
+  }
   parseClipLwo2(length) {
     var texture = {
       index: this.reader.getUint32(),
@@ -368,17 +366,17 @@ IFFParser.prototype = {
     }
     this.tree.textures.push(texture);
     this.currentForm = texture;
-  },
+  }
   parseImage() {
     this.reader.skip(8);
     this.currentForm.fileName = this.reader.getString();
-  },
+  }
   parseXVAL(type, length) {
     var endOffset = this.reader.offset + length - 4;
     this.reader.skip(8);
     this.currentForm[type] = this.reader.getFloat32();
     this.reader.setOffset(endOffset);
-  },
+  }
   parseXVAL3(type, length) {
     var endOffset = this.reader.offset + length - 4;
     this.reader.skip(8);
@@ -388,7 +386,7 @@ IFFParser.prototype = {
       z: this.reader.getFloat32()
     };
     this.reader.setOffset(endOffset);
-  },
+  }
   // Tags associated with an object
   // OTAG { type[ID4], tag-string[S0] }
   parseObjectTag() {
@@ -397,7 +395,7 @@ IFFParser.prototype = {
     this.tree.objectTags[this.reader.getIDTag()] = {
       tagString: this.reader.getString()
     };
-  },
+  }
   // Signals the start of a new layer. All the data chunks which follow will be included in this layer until another layer chunk is encountered.
   // LAYR: number[U2], flags[U2], pivot[VEC12], name[S0], parent[U2]
   parseLayer(length) {
@@ -413,16 +411,16 @@ IFFParser.prototype = {
     this.currentLayer = layer;
     var parsedLength = 16 + stringOffset(this.currentLayer.name);
     this.currentLayer.parent = parsedLength < length ? this.reader.getUint16() : -1;
-  },
+  }
   // VEC12 * ( F4 + F4 + F4 ) array of x,y,z vectors
   // Converting from left to right handed coordinate system:
   // x -> -x and switch material FrontSide -> BackSide
   parsePoints(length) {
     this.currentPoints = [];
-    for (let i = 0; i < length / 4; i += 3) {
+    for (var i = 0; i < length / 4; i += 3) {
       this.currentPoints.push(this.reader.getFloat32(), this.reader.getFloat32(), -this.reader.getFloat32());
     }
-  },
+  }
   // parse VMAP or VMAD
   // Associates a set of floating-point vectors with a set of points.
   // VMAP: { type[ID4], dimension[U2], name[S0], ( vert[VX], value[F4] # dimension ) * }
@@ -465,7 +463,7 @@ IFFParser.prototype = {
         console.warn("LWOLoader: unknown vertex map type: " + type);
         this.reader.skip(remainingLength);
     }
-  },
+  }
   parseUVMapping(name, finalOffset, discontinuous) {
     var uvIndices = [];
     var polyIndices = [];
@@ -492,7 +490,7 @@ IFFParser.prototype = {
         uvs
       };
     }
-  },
+  }
   parseMorphTargets(name, finalOffset, type) {
     var indices = [];
     var points = [];
@@ -508,7 +506,7 @@ IFFParser.prototype = {
       points,
       type
     };
-  },
+  }
   // A list of polygons for the current layer.
   // POLS { type[ID4], ( numvert+flags[U2], vert[VX] # numvert ) * }
   parsePolygonList(length) {
@@ -520,7 +518,7 @@ IFFParser.prototype = {
       var numverts = this.reader.getUint16();
       numverts = numverts & 1023;
       polygonDimensions.push(numverts);
-      for (let j = 0; j < numverts; j++)
+      for (var j = 0; j < numverts; j++)
         indices.push(this.reader.getVariableLengthIndex());
     }
     var geometryData = {
@@ -534,23 +532,23 @@ IFFParser.prototype = {
     else if (polygonDimensions[0] === 2)
       geometryData.type = "lines";
     this.currentLayer.geometry = geometryData;
-  },
+  }
   // Lists the tag strings that can be associated with polygons by the PTAG chunk.
   // TAGS { tag-string[S0] * }
   parseTagStrings(length) {
     this.tree.tags = this.reader.getStringArray(length);
-  },
+  }
   // Associates tags of a given type with polygons in the most recent POLS chunk.
   // PTAG { type[ID4], ( poly[VX], tag[U2] ) * }
   parsePolygonTagMapping(length) {
     var finalOffset = this.reader.offset + length;
     var type = this.reader.getIDTag();
-    if (type === "SURF") {
+    if (type === "SURF")
       this.parseMaterialIndices(finalOffset);
-    } else {
+    else {
       this.reader.skip(length - 4);
     }
-  },
+  }
   parseMaterialIndices(finalOffset) {
     this.currentLayer.geometry.materialIndices = [];
     while (this.reader.offset < finalOffset) {
@@ -558,87 +556,88 @@ IFFParser.prototype = {
       var materialIndex = this.reader.getUint16();
       this.currentLayer.geometry.materialIndices.push(polygonIndex, materialIndex);
     }
-  },
+  }
   parseUnknownCHUNK(blockID, length) {
     console.warn("LWOLoader: unknown chunk type: " + blockID + " length: " + length);
     var data = this.reader.getString(length);
     this.currentForm[blockID] = data;
   }
-};
-function DataViewReader(buffer) {
-  this.dv = new DataView(buffer);
-  this.offset = 0;
 }
-DataViewReader.prototype = {
-  constructor: DataViewReader,
-  size: function() {
+class DataViewReader {
+  constructor(buffer) {
+    this.dv = new DataView(buffer);
+    this.offset = 0;
+    this._textDecoder = new TextDecoder();
+    this._bytes = new Uint8Array(buffer);
+  }
+  size() {
     return this.dv.buffer.byteLength;
-  },
+  }
   setOffset(offset) {
     if (offset > 0 && offset < this.dv.buffer.byteLength) {
       this.offset = offset;
     } else {
       console.error("LWOLoader: invalid buffer offset");
     }
-  },
-  endOfFile: function() {
+  }
+  endOfFile() {
     if (this.offset >= this.size())
       return true;
     return false;
-  },
-  skip: function(length) {
+  }
+  skip(length) {
     this.offset += length;
-  },
-  getUint8: function() {
+  }
+  getUint8() {
     var value = this.dv.getUint8(this.offset);
     this.offset += 1;
     return value;
-  },
-  getUint16: function() {
+  }
+  getUint16() {
     var value = this.dv.getUint16(this.offset);
     this.offset += 2;
     return value;
-  },
-  getInt32: function() {
+  }
+  getInt32() {
     var value = this.dv.getInt32(this.offset, false);
     this.offset += 4;
     return value;
-  },
-  getUint32: function() {
+  }
+  getUint32() {
     var value = this.dv.getUint32(this.offset, false);
     this.offset += 4;
     return value;
-  },
-  getUint64: function() {
+  }
+  getUint64() {
     var low, high;
     high = this.getUint32();
     low = this.getUint32();
     return high * 4294967296 + low;
-  },
-  getFloat32: function() {
+  }
+  getFloat32() {
     var value = this.dv.getFloat32(this.offset, false);
     this.offset += 4;
     return value;
-  },
-  getFloat32Array: function(size) {
+  }
+  getFloat32Array(size) {
     var a = [];
-    for (let i = 0; i < size; i++) {
+    for (var i = 0; i < size; i++) {
       a.push(this.getFloat32());
     }
     return a;
-  },
-  getFloat64: function() {
+  }
+  getFloat64() {
     var value = this.dv.getFloat64(this.offset, this.littleEndian);
     this.offset += 8;
     return value;
-  },
-  getFloat64Array: function(size) {
+  }
+  getFloat64Array(size) {
     var a = [];
-    for (let i = 0; i < size; i++) {
+    for (var i = 0; i < size; i++) {
       a.push(this.getFloat64());
     }
     return a;
-  },
+  }
   // get variable-length index data type
   // VX ::= index[U2] | (index + 0xFF000000)[U4]
   // If the index value is less than 65,280 (0xFF00),then VX === U2
@@ -651,50 +650,45 @@ DataViewReader.prototype = {
       return this.getUint8() * 65536 + this.getUint8() * 256 + this.getUint8();
     }
     return firstByte * 256 + this.getUint8();
-  },
+  }
   // An ID tag is a sequence of 4 bytes containing 7-bit ASCII values
   getIDTag() {
     return this.getString(4);
-  },
-  getString: function(size) {
+  }
+  getString(size) {
     if (size === 0)
       return;
-    var a = [];
+    const start = this.offset;
+    let result;
+    let length;
     if (size) {
-      for (let i = 0; i < size; i++) {
-        a[i] = this.getUint8();
-      }
+      length = size;
+      result = this._textDecoder.decode(new Uint8Array(this.dv.buffer, start, size));
     } else {
-      var currentChar;
-      var len = 0;
-      while (currentChar !== 0) {
-        currentChar = this.getUint8();
-        if (currentChar !== 0)
-          a.push(currentChar);
-        len++;
-      }
-      if (!isEven(len + 1))
-        this.getUint8();
+      length = this._bytes.indexOf(0, start) - start;
+      result = this._textDecoder.decode(new Uint8Array(this.dv.buffer, start, length));
+      length++;
+      length += length % 2;
     }
-    return LoaderUtils.decodeText(new Uint8Array(a));
-  },
-  getStringArray: function(size) {
+    this.skip(length);
+    return result;
+  }
+  getStringArray(size) {
     var a = this.getString(size);
     a = a.split("\0");
     return a.filter(Boolean);
   }
-};
-function Debugger() {
-  this.active = false;
-  this.depth = 0;
-  this.formList = [];
 }
-Debugger.prototype = {
-  constructor: Debugger,
-  enable: function() {
+class Debugger {
+  constructor() {
+    this.active = false;
+    this.depth = 0;
+    this.formList = [];
+  }
+  enable() {
     this.active = true;
-  },
-  log: function() {
+  }
+  log() {
     if (!this.active)
       return;
     var nodeType;
@@ -722,11 +716,11 @@ Debugger.prototype = {
       this.formList.push(this.dataOffset + this.length);
     }
     this.skipped = false;
-  },
-  closeForms: function() {
+  }
+  closeForms() {
     if (!this.active)
       return;
-    for (let i = this.formList.length - 1; i >= 0; i--) {
+    for (var i = this.formList.length - 1; i >= 0; i--) {
       if (this.offset >= this.formList[i]) {
         this.depth -= 1;
         console.log("| ".repeat(this.depth) + "}");
@@ -734,7 +728,7 @@ Debugger.prototype = {
       }
     }
   }
-};
+}
 function isEven(num) {
   return num % 2;
 }
@@ -742,7 +736,7 @@ function stringOffset(string) {
   return string.length + 1 + (isEven(string.length + 1) ? 1 : 0);
 }
 function printBuffer(buffer, from, to) {
-  console.log(LoaderUtils.decodeText(new Uint8Array(buffer, from, to)));
+  console.log(new TextDecoder().decode(new Uint8Array(buffer, from, to)));
 }
 export {
   IFFParser

package/dist/loaders/lwo/LWO2Parser.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function LWO2Parser(IFFParser) {
-  this.IFF = IFFParser;
-}
-LWO2Parser.prototype = {
-  constructor: LWO2Parser,
-  parseBlock: function() {
+class LWO2Parser {
+  constructor(IFFParser) {
+    this.IFF = IFFParser;
+  }
+  parseBlock() {
     this.IFF.debugger.offset = this.IFF.reader.offset;
     this.IFF.debugger.closeForms();
-    var blockID = this.IFF.reader.getIDTag();
-    var length = this.IFF.reader.getUint32();
+    const blockID = this.IFF.reader.getIDTag();
+    let length = this.IFF.reader.getUint32();
     if (length > this.IFF.reader.dv.byteLength - this.IFF.reader.offset) {
       this.IFF.reader.offset -= 4;
       length = this.IFF.reader.getUint16();
@@ -69,6 +68,7 @@ LWO2Parser.prototype = {
       case "WRPW":
       case "WRPH":
       case "NMOD":
+      case "NSEL":
       case "NPRW":
       case "NPLA":
       case "NODS":
@@ -172,13 +172,10 @@ LWO2Parser.prototype = {
         this.IFF.currentForm.channelName = this.IFF.reader.getString();
         break;
       case "WRAP":
-        this.IFF.currentForm.wrap = {
-          w: this.IFF.reader.getUint16(),
-          h: this.IFF.reader.getUint16()
-        };
+        this.IFF.currentForm.wrap = { w: this.IFF.reader.getUint16(), h: this.IFF.reader.getUint16() };
         break;
       case "IMAG":
-        var index = this.IFF.reader.getVariableLengthIndex();
+        const index = this.IFF.reader.getVariableLengthIndex();
         this.IFF.currentForm.imageIndex = index;
         break;
       case "OREF":
@@ -233,43 +230,31 @@ LWO2Parser.prototype = {
           this.IFF.reader.skip(length);
         break;
       case "SMAN":
-        var maxSmoothingAngle = this.IFF.reader.getFloat32();
+        const maxSmoothingAngle = this.IFF.reader.getFloat32();
         this.IFF.currentSurface.attributes.smooth = maxSmoothingAngle < 0 ? false : true;
         break;
       case "COLR":
-        this.IFF.currentSurface.attributes.Color = {
-          value: this.IFF.reader.getFloat32Array(3)
-        };
+        this.IFF.currentSurface.attributes.Color = { value: this.IFF.reader.getFloat32Array(3) };
         this.IFF.reader.skip(2);
         break;
       case "LUMI":
-        this.IFF.currentSurface.attributes.Luminosity = {
-          value: this.IFF.reader.getFloat32()
-        };
+        this.IFF.currentSurface.attributes.Luminosity = { value: this.IFF.reader.getFloat32() };
         this.IFF.reader.skip(2);
         break;
       case "SPEC":
-        this.IFF.currentSurface.attributes.Specular = {
-          value: this.IFF.reader.getFloat32()
-        };
+        this.IFF.currentSurface.attributes.Specular = { value: this.IFF.reader.getFloat32() };
         this.IFF.reader.skip(2);
         break;
       case "DIFF":
-        this.IFF.currentSurface.attributes.Diffuse = {
-          value: this.IFF.reader.getFloat32()
-        };
+        this.IFF.currentSurface.attributes.Diffuse = { value: this.IFF.reader.getFloat32() };
         this.IFF.reader.skip(2);
         break;
       case "REFL":
-        this.IFF.currentSurface.attributes.Reflection = {
-          value: this.IFF.reader.getFloat32()
-        };
+        this.IFF.currentSurface.attributes.Reflection = { value: this.IFF.reader.getFloat32() };
         this.IFF.reader.skip(2);
         break;
       case "GLOS":
-        this.IFF.currentSurface.attributes.Glossiness = {
-          value: this.IFF.reader.getFloat32()
-        };
+        this.IFF.currentSurface.attributes.Glossiness = { value: this.IFF.reader.getFloat32() };
         this.IFF.reader.skip(2);
         break;
       case "TRAN":
@@ -323,5 +308,5 @@ LWO2Parser.prototype = {
       this.IFF.currentForm = this.IFF.parentForm;
     }
   }
-};
+}
 exports.LWO2Parser = LWO2Parser;