opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/lwo/LWO3Parser.js

@@ -0,0 +1,406 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.LWO3Parser = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.LWO3Parser = LWO3Parser;
+
+  function LWO3Parser(IFFParser) {
+    this.IFF = IFFParser;
+  }
+
+  LWO3Parser.prototype = {
+    constructor: LWO3Parser,
+    parseBlock: function 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(); // size of data in bytes
+
+      this.IFF.debugger.dataOffset = this.IFF.reader.offset;
+      this.IFF.debugger.length = length; // Data types may be found in either LWO2 OR LWO3 spec
+
+      switch (blockID) {
+        case 'FORM':
+          // form blocks may consist of sub -chunks or sub-forms
+          this.IFF.parseForm(length);
+          break;
+        // SKIPPED CHUNKS
+        // MISC skipped
+
+        case 'ICON': // Thumbnail Icon Image
+
+        case 'VMPA': // Vertex Map Parameter
+
+        case 'BBOX': // bounding box
+        // case 'VMMD':
+        // case 'VTYP':
+        // normal maps can be specified, normally on models imported from other applications. Currently ignored
+
+        case 'NORM': // ENVL FORM skipped
+
+        case 'PRE ': // Pre-loop behavior for the keyframe
+
+        case 'POST': // Post-loop behavior for the keyframe
+
+        case 'KEY ':
+        case 'SPAN': // CLIP FORM skipped
+
+        case 'TIME':
+        case 'CLRS':
+        case 'CLRA':
+        case 'FILT':
+        case 'DITH':
+        case 'CONT':
+        case 'BRIT':
+        case 'SATR':
+        case 'HUE ':
+        case 'GAMM':
+        case 'NEGA':
+        case 'IFLT':
+        case 'PFLT': // Image Map Layer skipped
+
+        case 'PROJ':
+        case 'AXIS':
+        case 'AAST':
+        case 'PIXB':
+        case 'STCK': // Procedural Textures skipped
+
+        case 'VALU': // Gradient Textures skipped
+
+        case 'PNAM':
+        case 'INAM':
+        case 'GRST':
+        case 'GREN':
+        case 'GRPT':
+        case 'FKEY':
+        case 'IKEY': // Texture Mapping Form skipped
+
+        case 'CSYS': // Surface CHUNKs skipped
+
+        case 'OPAQ': // top level 'opacity' checkbox
+
+        case 'CMAP': // clip map
+        // Surface node CHUNKS skipped
+        // These mainly specify the node editor setup in LW
+
+        case 'NLOC':
+        case 'NZOM':
+        case 'NVER':
+        case 'NSRV':
+        case 'NCRD':
+        case 'NMOD':
+        case 'NSEL':
+        case 'NPRW':
+        case 'NPLA':
+        case 'VERS':
+        case 'ENUM':
+        case 'TAG ': // Car Material CHUNKS
+
+        case 'CGMD':
+        case 'CGTY':
+        case 'CGST':
+        case 'CGEN':
+        case 'CGTS':
+        case 'CGTE':
+        case 'OSMP':
+        case 'OMDE':
+        case 'OUTR':
+        case 'FLAG':
+        case 'TRNL':
+        case 'SHRP':
+        case 'RFOP':
+        case 'RSAN':
+        case 'TROP':
+        case 'RBLR':
+        case 'TBLR':
+        case 'CLRH':
+        case 'CLRF':
+        case 'ADTR':
+        case 'GLOW':
+        case 'LINE':
+        case 'ALPH':
+        case 'VCOL':
+        case 'ENAB':
+          this.IFF.debugger.skipped = true;
+          this.IFF.reader.skip(length);
+          break;
+        // Texture node chunks (not in spec)
+
+        case 'IPIX': // usePixelBlending
+
+        case 'IMIP': // useMipMaps
+
+        case 'IMOD': // imageBlendingMode
+
+        case 'AMOD': // unknown
+
+        case 'IINV': // imageInvertAlpha
+
+        case 'INCR': // imageInvertColor
+
+        case 'IAXS': // imageAxis ( for non-UV maps)
+
+        case 'IFOT': // imageFallofType
+
+        case 'ITIM': // timing for animated textures
+
+        case 'IWRL':
+        case 'IUTI':
+        case 'IINX':
+        case 'IINY':
+        case 'IINZ':
+        case 'IREF':
+          // possibly a VX for reused texture nodes
+          if (length === 4) this.IFF.currentNode[blockID] = this.IFF.reader.getInt32();else this.IFF.reader.skip(length);
+          break;
+
+        case 'OTAG':
+          this.IFF.parseObjectTag();
+          break;
+
+        case 'LAYR':
+          this.IFF.parseLayer(length);
+          break;
+
+        case 'PNTS':
+          this.IFF.parsePoints(length);
+          break;
+
+        case 'VMAP':
+          this.IFF.parseVertexMapping(length);
+          break;
+
+        case 'POLS':
+          this.IFF.parsePolygonList(length);
+          break;
+
+        case 'TAGS':
+          this.IFF.parseTagStrings(length);
+          break;
+
+        case 'PTAG':
+          this.IFF.parsePolygonTagMapping(length);
+          break;
+
+        case 'VMAD':
+          this.IFF.parseVertexMapping(length, true);
+          break;
+        // Misc CHUNKS
+
+        case 'DESC':
+          // Description Line
+          this.IFF.currentForm.description = this.IFF.reader.getString();
+          break;
+
+        case 'TEXT':
+        case 'CMNT':
+        case 'NCOM':
+          this.IFF.currentForm.comment = this.IFF.reader.getString();
+          break;
+        // Envelope Form
+
+        case 'NAME':
+          this.IFF.currentForm.channelName = this.IFF.reader.getString();
+          break;
+        // Image Map Layer
+
+        case 'WRAP':
+          this.IFF.currentForm.wrap = {
+            w: this.IFF.reader.getUint16(),
+            h: this.IFF.reader.getUint16()
+          };
+          break;
+
+        case 'IMAG':
+          var index = this.IFF.reader.getVariableLengthIndex();
+          this.IFF.currentForm.imageIndex = index;
+          break;
+        // Texture Mapping Form
+
+        case 'OREF':
+          this.IFF.currentForm.referenceObject = this.IFF.reader.getString();
+          break;
+
+        case 'ROID':
+          this.IFF.currentForm.referenceObjectID = this.IFF.reader.getUint32();
+          break;
+        // Surface Blocks
+
+        case 'SSHN':
+          this.IFF.currentSurface.surfaceShaderName = this.IFF.reader.getString();
+          break;
+
+        case 'AOVN':
+          this.IFF.currentSurface.surfaceCustomAOVName = this.IFF.reader.getString();
+          break;
+        // Nodal Blocks
+
+        case 'NSTA':
+          this.IFF.currentForm.disabled = this.IFF.reader.getUint16();
+          break;
+
+        case 'NRNM':
+          this.IFF.currentForm.realName = this.IFF.reader.getString();
+          break;
+
+        case 'NNME':
+          this.IFF.currentForm.refName = this.IFF.reader.getString();
+          this.IFF.currentSurface.nodes[this.IFF.currentForm.refName] = this.IFF.currentForm;
+          break;
+        // Nodal Blocks : connections
+
+        case 'INME':
+          if (!this.IFF.currentForm.nodeName) this.IFF.currentForm.nodeName = [];
+          this.IFF.currentForm.nodeName.push(this.IFF.reader.getString());
+          break;
+
+        case 'IINN':
+          if (!this.IFF.currentForm.inputNodeName) this.IFF.currentForm.inputNodeName = [];
+          this.IFF.currentForm.inputNodeName.push(this.IFF.reader.getString());
+          break;
+
+        case 'IINM':
+          if (!this.IFF.currentForm.inputName) this.IFF.currentForm.inputName = [];
+          this.IFF.currentForm.inputName.push(this.IFF.reader.getString());
+          break;
+
+        case 'IONM':
+          if (!this.IFF.currentForm.inputOutputName) this.IFF.currentForm.inputOutputName = [];
+          this.IFF.currentForm.inputOutputName.push(this.IFF.reader.getString());
+          break;
+
+        case 'FNAM':
+          this.IFF.currentForm.fileName = this.IFF.reader.getString();
+          break;
+
+        case 'CHAN':
+          // NOTE: ENVL Forms may also have CHAN chunk, however ENVL is currently ignored
+          if (length === 4) this.IFF.currentForm.textureChannel = this.IFF.reader.getIDTag();else this.IFF.reader.skip(length);
+          break;
+        // LWO2 Spec chunks: these are needed since the SURF FORMs are often in LWO2 format
+
+        case 'SMAN':
+          var maxSmoothingAngle = this.IFF.reader.getFloat32();
+          this.IFF.currentSurface.attributes.smooth = maxSmoothingAngle < 0 ? false : true;
+          break;
+        // LWO2: Basic Surface Parameters
+
+        case 'COLR':
+          this.IFF.currentSurface.attributes.Color = {
+            value: this.IFF.reader.getFloat32Array(3)
+          };
+          this.IFF.reader.skip(2); // VX: envelope
+
+          break;
+
+        case 'LUMI':
+          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.reader.skip(2);
+          break;
+
+        case 'DIFF':
+          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.reader.skip(2);
+          break;
+
+        case 'GLOS':
+          this.IFF.currentSurface.attributes.Glossiness = {
+            value: this.IFF.reader.getFloat32()
+          };
+          this.IFF.reader.skip(2);
+          break;
+
+        case 'TRAN':
+          this.IFF.currentSurface.attributes.opacity = this.IFF.reader.getFloat32();
+          this.IFF.reader.skip(2);
+          break;
+
+        case 'BUMP':
+          this.IFF.currentSurface.attributes.bumpStrength = this.IFF.reader.getFloat32();
+          this.IFF.reader.skip(2);
+          break;
+
+        case 'SIDE':
+          this.IFF.currentSurface.attributes.side = this.IFF.reader.getUint16();
+          break;
+
+        case 'RIMG':
+          this.IFF.currentSurface.attributes.reflectionMap = this.IFF.reader.getVariableLengthIndex();
+          break;
+
+        case 'RIND':
+          this.IFF.currentSurface.attributes.refractiveIndex = this.IFF.reader.getFloat32();
+          this.IFF.reader.skip(2);
+          break;
+
+        case 'TIMG':
+          this.IFF.currentSurface.attributes.refractionMap = this.IFF.reader.getVariableLengthIndex();
+          break;
+
+        case 'IMAP':
+          this.IFF.currentSurface.attributes.imageMapIndex = this.IFF.reader.getUint32();
+          break;
+
+        case 'IUVI':
+          // uv channel name
+          this.IFF.currentNode.UVChannel = this.IFF.reader.getString(length);
+          break;
+
+        case 'IUTL':
+          // widthWrappingMode: 0 = Reset, 1 = Repeat, 2 = Mirror, 3 = Edge
+          this.IFF.currentNode.widthWrappingMode = this.IFF.reader.getUint32();
+          break;
+
+        case 'IVTL':
+          // heightWrappingMode
+          this.IFF.currentNode.heightWrappingMode = this.IFF.reader.getUint32();
+          break;
+
+        default:
+          this.IFF.parseUnknownCHUNK(blockID, length);
+      }
+
+      if (blockID != 'FORM') {
+        this.IFF.debugger.node = 1;
+        this.IFF.debugger.nodeID = blockID;
+        this.IFF.debugger.log();
+      }
+
+      if (this.IFF.reader.offset >= this.IFF.currentFormEnd) {
+        this.IFF.currentForm = this.IFF.parentForm;
+      }
+    }
+  };
+});

data/lib-opal/js_wrap/three/math/Capsule.js

@@ -0,0 +1,133 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.Capsule = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Capsule = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  var _v1 = new _three.Vector3();
+
+  var _v2 = new _three.Vector3();
+
+  var _v3 = new _three.Vector3();
+
+  var EPS = 1e-10;
+
+  var Capsule = /*#__PURE__*/function () {
+    function Capsule() {
+      var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _three.Vector3(0, 0, 0);
+      var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Vector3(0, 1, 0);
+      var radius = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+
+      _classCallCheck(this, Capsule);
+
+      this.start = start;
+      this.end = end;
+      this.radius = radius;
+    }
+
+    _createClass(Capsule, [{
+      key: "clone",
+      value: function clone() {
+        return new Capsule(this.start.clone(), this.end.clone(), this.radius);
+      }
+    }, {
+      key: "set",
+      value: function set(start, end, radius) {
+        this.start.copy(start);
+        this.end.copy(end);
+        this.radius = radius;
+      }
+    }, {
+      key: "copy",
+      value: function copy(capsule) {
+        this.start.copy(capsule.start);
+        this.end.copy(capsule.end);
+        this.radius = capsule.radius;
+      }
+    }, {
+      key: "getCenter",
+      value: function getCenter(target) {
+        return target.copy(this.end).add(this.start).multiplyScalar(0.5);
+      }
+    }, {
+      key: "translate",
+      value: function translate(v) {
+        this.start.add(v);
+        this.end.add(v);
+      }
+    }, {
+      key: "checkAABBAxis",
+      value: function checkAABBAxis(p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius) {
+        return (minx - p1x < radius || minx - p2x < radius) && (p1x - maxx < radius || p2x - maxx < radius) && (miny - p1y < radius || miny - p2y < radius) && (p1y - maxy < radius || p2y - maxy < radius);
+      }
+    }, {
+      key: "intersectsBox",
+      value: function intersectsBox(box) {
+        return this.checkAABBAxis(this.start.x, this.start.y, this.end.x, this.end.y, box.min.x, box.max.x, box.min.y, box.max.y, this.radius) && this.checkAABBAxis(this.start.x, this.start.z, this.end.x, this.end.z, box.min.x, box.max.x, box.min.z, box.max.z, this.radius) && this.checkAABBAxis(this.start.y, this.start.z, this.end.y, this.end.z, box.min.y, box.max.y, box.min.z, box.max.z, this.radius);
+      }
+    }, {
+      key: "lineLineMinimumPoints",
+      value: function lineLineMinimumPoints(line1, line2) {
+        var r = _v1.copy(line1.end).sub(line1.start);
+
+        var s = _v2.copy(line2.end).sub(line2.start);
+
+        var w = _v3.copy(line2.start).sub(line1.start);
+
+        var a = r.dot(s),
+            b = r.dot(r),
+            c = s.dot(s),
+            d = s.dot(w),
+            e = r.dot(w);
+        var t1, t2;
+        var divisor = b * c - a * a;
+
+        if (Math.abs(divisor) < EPS) {
+          var d1 = -d / c;
+          var d2 = (a - d) / c;
+
+          if (Math.abs(d1 - 0.5) < Math.abs(d2 - 0.5)) {
+            t1 = 0;
+            t2 = d1;
+          } else {
+            t1 = 1;
+            t2 = d2;
+          }
+        } else {
+          t1 = (d * a + e * c) / divisor;
+          t2 = (t1 * a - d) / c;
+        }
+
+        t2 = Math.max(0, Math.min(1, t2));
+        t1 = Math.max(0, Math.min(1, t1));
+        var point1 = r.multiplyScalar(t1).add(line1.start);
+        var point2 = s.multiplyScalar(t2).add(line2.start);
+        return [point1, point2];
+      }
+    }]);
+
+    return Capsule;
+  }();
+
+  _exports.Capsule = Capsule;
+});

data/lib-opal/js_wrap/three/math/ColorConverter.js

@@ -0,0 +1,104 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.ColorConverter = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ColorConverter = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  var _hsl = {};
+
+  var ColorConverter = /*#__PURE__*/function () {
+    function ColorConverter() {
+      _classCallCheck(this, ColorConverter);
+    }
+
+    _createClass(ColorConverter, null, [{
+      key: "setHSV",
+      value: function setHSV(color, h, s, v) {
+        // https://gist.github.com/xpansive/1337890#file-index-js
+        h = _three.MathUtils.euclideanModulo(h, 1);
+        s = _three.MathUtils.clamp(s, 0, 1);
+        v = _three.MathUtils.clamp(v, 0, 1);
+        return color.setHSL(h, s * v / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5);
+      }
+    }, {
+      key: "getHSV",
+      value: function getHSV(color, target) {
+        if (target === undefined) {
+          console.warn('THREE.ColorConverter: .getHSV() target is now required');
+          target = {
+            h: 0,
+            s: 0,
+            l: 0
+          };
+        }
+
+        color.getHSL(_hsl); // based on https://gist.github.com/xpansive/1337890#file-index-js
+
+        _hsl.s *= _hsl.l < 0.5 ? _hsl.l : 1 - _hsl.l;
+        target.h = _hsl.h;
+        target.s = 2 * _hsl.s / (_hsl.l + _hsl.s);
+        target.v = _hsl.l + _hsl.s;
+        return target;
+      } // where c, m, y, k is between 0 and 1
+
+    }, {
+      key: "setCMYK",
+      value: function setCMYK(color, c, m, y, k) {
+        var r = (1 - c) * (1 - k);
+        var g = (1 - m) * (1 - k);
+        var b = (1 - y) * (1 - k);
+        return color.setRGB(r, g, b);
+      }
+    }, {
+      key: "getCMYK",
+      value: function getCMYK(color, target) {
+        if (target === undefined) {
+          console.warn('THREE.ColorConverter: .getCMYK() target is now required');
+          target = {
+            c: 0,
+            m: 0,
+            y: 0,
+            k: 0
+          };
+        }
+
+        var r = color.r;
+        var g = color.g;
+        var b = color.b;
+        var k = 1 - Math.max(r, g, b);
+        var c = (1 - r - k) / (1 - k);
+        var m = (1 - g - k) / (1 - k);
+        var y = (1 - b - k) / (1 - k);
+        target.c = c;
+        target.m = m;
+        target.y = y;
+        target.k = k;
+        return target;
+      }
+    }]);
+
+    return ColorConverter;
+  }();
+
+  _exports.ColorConverter = ColorConverter;
+});