opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/exporters/USDZExporter.js

@@ -0,0 +1,402 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../libs/fflate.module.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../libs/fflate.module.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.fflateModule);
+    global.USDZExporter = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, fflate) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.USDZExporter = void 0;
+  fflate = _interopRequireWildcard(fflate);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+  function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+  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 USDZExporter = /*#__PURE__*/function () {
+    function USDZExporter() {
+      _classCallCheck(this, USDZExporter);
+    }
+
+    _createClass(USDZExporter, [{
+      key: "parse",
+      value: function () {
+        var _parse = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(scene) {
+          var files, modelFileName, output, materials, textures, _loop, id, offset, filename, file, headerSize, offsetMod64, padLength, padding;
+
+          return regeneratorRuntime.wrap(function _callee$(_context2) {
+            while (1) {
+              switch (_context2.prev = _context2.next) {
+                case 0:
+                  files = {};
+                  modelFileName = 'model.usda'; // model file should be first in USDZ archive so we init it here
+
+                  files[modelFileName] = null;
+                  output = buildHeader();
+                  materials = {};
+                  textures = {};
+                  scene.traverseVisible(function (object) {
+                    if (object.isMesh) {
+                      if (object.material.isMeshStandardMaterial) {
+                        var geometry = object.geometry;
+                        var material = object.material;
+                        var geometryFileName = 'geometries/Geometry_' + geometry.id + '.usd';
+
+                        if (!(geometryFileName in files)) {
+                          var meshObject = buildMeshObject(geometry);
+                          files[geometryFileName] = buildUSDFileAsString(meshObject);
+                        }
+
+                        if (!(material.uuid in materials)) {
+                          materials[material.uuid] = material;
+                        }
+
+                        output += buildXform(object, geometry, material);
+                      } else {
+                        console.warn('THREE.USDZExporter: Unsupported material type (USDZ only supports MeshStandardMaterial)', object);
+                      }
+                    }
+                  });
+                  output += buildMaterials(materials, textures);
+                  files[modelFileName] = fflate.strToU8(output);
+                  output = null;
+                  _loop = /*#__PURE__*/regeneratorRuntime.mark(function _loop(id) {
+                    var texture, color, isRGBA, canvas, blob;
+                    return regeneratorRuntime.wrap(function _loop$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            texture = textures[id];
+                            color = id.split('_')[1];
+                            isRGBA = texture.format === 1023;
+                            canvas = imageToCanvas(texture.image, color);
+                            _context.next = 6;
+                            return new Promise(function (resolve) {
+                              return canvas.toBlob(resolve, isRGBA ? 'image/png' : 'image/jpeg', 1);
+                            });
+
+                          case 6:
+                            blob = _context.sent;
+                            _context.t0 = Uint8Array;
+                            _context.next = 10;
+                            return blob.arrayBuffer();
+
+                          case 10:
+                            _context.t1 = _context.sent;
+                            files["textures/Texture_".concat(id, ".").concat(isRGBA ? 'png' : 'jpg')] = new _context.t0(_context.t1);
+
+                          case 12:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _loop);
+                  });
+                  _context2.t0 = regeneratorRuntime.keys(textures);
+
+                case 12:
+                  if ((_context2.t1 = _context2.t0()).done) {
+                    _context2.next = 17;
+                    break;
+                  }
+
+                  id = _context2.t1.value;
+                  return _context2.delegateYield(_loop(id), "t2", 15);
+
+                case 15:
+                  _context2.next = 12;
+                  break;
+
+                case 17:
+                  // 64 byte alignment
+                  // https://github.com/101arrowz/fflate/issues/39#issuecomment-777263109
+                  offset = 0;
+
+                  for (filename in files) {
+                    file = files[filename];
+                    headerSize = 34 + filename.length;
+                    offset += headerSize;
+                    offsetMod64 = offset & 63;
+
+                    if (offsetMod64 !== 4) {
+                      padLength = 64 - offsetMod64;
+                      padding = new Uint8Array(padLength);
+                      files[filename] = [file, {
+                        extra: {
+                          12345: padding
+                        }
+                      }];
+                    }
+
+                    offset = file.length;
+                  }
+
+                  return _context2.abrupt("return", fflate.zipSync(files, {
+                    level: 0
+                  }));
+
+                case 20:
+                case "end":
+                  return _context2.stop();
+              }
+            }
+          }, _callee);
+        }));
+
+        function parse(_x) {
+          return _parse.apply(this, arguments);
+        }
+
+        return parse;
+      }()
+    }]);
+
+    return USDZExporter;
+  }();
+
+  _exports.USDZExporter = USDZExporter;
+
+  function imageToCanvas(image, color) {
+    if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
+      var scale = 1024 / Math.max(image.width, image.height);
+      var canvas = document.createElement('canvas');
+      canvas.width = image.width * Math.min(1, scale);
+      canvas.height = image.height * Math.min(1, scale);
+      var context = canvas.getContext('2d');
+      context.drawImage(image, 0, 0, canvas.width, canvas.height);
+
+      if (color !== undefined) {
+        var hex = parseInt(color, 16);
+        var r = (hex >> 16 & 255) / 255;
+        var g = (hex >> 8 & 255) / 255;
+        var b = (hex & 255) / 255;
+        var imagedata = context.getImageData(0, 0, canvas.width, canvas.height);
+        var data = imagedata.data;
+
+        for (var i = 0; i < data.length; i += 4) {
+          data[i + 0] = data[i + 0] * r;
+          data[i + 1] = data[i + 1] * g;
+          data[i + 2] = data[i + 2] * b;
+        }
+
+        context.putImageData(imagedata, 0, 0);
+      }
+
+      return canvas;
+    }
+  } //
+
+
+  var PRECISION = 7;
+
+  function buildHeader() {
+    return "#usda 1.0\n(\n    customLayerData = {\n        string creator = \"Three.js USDZExporter\"\n    }\n    metersPerUnit = 1\n    upAxis = \"Y\"\n)\n\n";
+  }
+
+  function buildUSDFileAsString(dataToInsert) {
+    var output = buildHeader();
+    output += dataToInsert;
+    return fflate.strToU8(output);
+  } // Xform
+
+
+  function buildXform(object, geometry, material) {
+    var name = 'Object_' + object.id;
+    var transform = buildMatrix(object.matrixWorld);
+
+    if (object.matrixWorld.determinant() < 0) {
+      console.warn('THREE.USDZExporter: USDZ does not support negative scales', object);
+    }
+
+    return "def Xform \"".concat(name, "\" (\n    prepend references = @./geometries/Geometry_").concat(geometry.id, ".usd@</Geometry>\n)\n{\n    matrix4d xformOp:transform = ").concat(transform, "\n    uniform token[] xformOpOrder = [\"xformOp:transform\"]\n\n    rel material:binding = </Materials/Material_").concat(material.id, ">\n}\n\n");
+  }
+
+  function buildMatrix(matrix) {
+    var array = matrix.elements;
+    return "( ".concat(buildMatrixRow(array, 0), ", ").concat(buildMatrixRow(array, 4), ", ").concat(buildMatrixRow(array, 8), ", ").concat(buildMatrixRow(array, 12), " )");
+  }
+
+  function buildMatrixRow(array, offset) {
+    return "(".concat(array[offset + 0], ", ").concat(array[offset + 1], ", ").concat(array[offset + 2], ", ").concat(array[offset + 3], ")");
+  } // Mesh
+
+
+  function buildMeshObject(geometry) {
+    var mesh = buildMesh(geometry);
+    return "\ndef \"Geometry\"\n{\n  ".concat(mesh, "\n}\n");
+  }
+
+  function buildMesh(geometry) {
+    var name = 'Geometry';
+    var attributes = geometry.attributes;
+    var count = attributes.position.count;
+    return "\n    def Mesh \"".concat(name, "\"\n    {\n        int[] faceVertexCounts = [").concat(buildMeshVertexCount(geometry), "]\n        int[] faceVertexIndices = [").concat(buildMeshVertexIndices(geometry), "]\n        normal3f[] normals = [").concat(buildVector3Array(attributes.normal, count), "] (\n            interpolation = \"vertex\"\n        )\n        point3f[] points = [").concat(buildVector3Array(attributes.position, count), "]\n        float2[] primvars:st = [").concat(buildVector2Array(attributes.uv, count), "] (\n            interpolation = \"vertex\"\n        )\n        uniform token subdivisionScheme = \"none\"\n    }\n");
+  }
+
+  function buildMeshVertexCount(geometry) {
+    var count = geometry.index !== null ? geometry.index.count : geometry.attributes.position.count;
+    return Array(count / 3).fill(3).join(', ');
+  }
+
+  function buildMeshVertexIndices(geometry) {
+    var index = geometry.index;
+    var array = [];
+
+    if (index !== null) {
+      for (var i = 0; i < index.count; i++) {
+        array.push(index.getX(i));
+      }
+    } else {
+      var length = geometry.attributes.position.count;
+
+      for (var _i = 0; _i < length; _i++) {
+        array.push(_i);
+      }
+    }
+
+    return array.join(', ');
+  }
+
+  function buildVector3Array(attribute, count) {
+    if (attribute === undefined) {
+      console.warn('USDZExporter: Normals missing.');
+      return Array(count).fill('(0, 0, 0)').join(', ');
+    }
+
+    var array = [];
+
+    for (var i = 0; i < attribute.count; i++) {
+      var x = attribute.getX(i);
+      var y = attribute.getY(i);
+      var z = attribute.getZ(i);
+      array.push("(".concat(x.toPrecision(PRECISION), ", ").concat(y.toPrecision(PRECISION), ", ").concat(z.toPrecision(PRECISION), ")"));
+    }
+
+    return array.join(', ');
+  }
+
+  function buildVector2Array(attribute, count) {
+    if (attribute === undefined) {
+      console.warn('USDZExporter: UVs missing.');
+      return Array(count).fill('(0, 0)').join(', ');
+    }
+
+    var array = [];
+
+    for (var i = 0; i < attribute.count; i++) {
+      var x = attribute.getX(i);
+      var y = attribute.getY(i);
+      array.push("(".concat(x.toPrecision(PRECISION), ", ").concat(1 - y.toPrecision(PRECISION), ")"));
+    }
+
+    return array.join(', ');
+  } // Materials
+
+
+  function buildMaterials(materials, textures) {
+    var array = [];
+
+    for (var uuid in materials) {
+      var material = materials[uuid];
+      array.push(buildMaterial(material, textures));
+    }
+
+    return "def \"Materials\"\n{\n".concat(array.join(''), "\n}\n\n");
+  }
+
+  function buildMaterial(material, textures) {
+    // https://graphics.pixar.com/usd/docs/UsdPreviewSurface-Proposal.html
+    var pad = '            ';
+    var inputs = [];
+    var samplers = [];
+
+    function buildTexture(texture, mapType, color) {
+      var id = texture.id + (color ? '_' + color.getHexString() : '');
+      var isRGBA = texture.format === 1023;
+      textures[id] = texture;
+      return "\n        def Shader \"Transform2d_".concat(mapType, "\" (\n            sdrMetadata = {\n                string role = \"math\"\n            }\n        )\n        {\n            uniform token info:id = \"UsdTransform2d\"\n            float2 inputs:in.connect = </Materials/Material_").concat(material.id, "/uvReader_st.outputs:result>\n            float2 inputs:scale = ").concat(buildVector2(texture.repeat), "\n            float2 inputs:translation = ").concat(buildVector2(texture.offset), "\n            float2 outputs:result\n        }\n\n        def Shader \"Texture_").concat(texture.id, "_").concat(mapType, "\"\n        {\n            uniform token info:id = \"UsdUVTexture\"\n            asset inputs:file = @textures/Texture_").concat(id, ".").concat(isRGBA ? 'png' : 'jpg', "@\n            float2 inputs:st.connect = </Materials/Material_").concat(material.id, "/Transform2d_").concat(mapType, ".outputs:result>\n            token inputs:wrapS = \"repeat\"\n            token inputs:wrapT = \"repeat\"\n            float outputs:r\n            float outputs:g\n            float outputs:b\n            float3 outputs:rgb\n        }");
+    }
+
+    if (material.map !== null) {
+      inputs.push("".concat(pad, "color3f inputs:diffuseColor.connect = </Materials/Material_").concat(material.id, "/Texture_").concat(material.map.id, "_diffuse.outputs:rgb>"));
+      samplers.push(buildTexture(material.map, 'diffuse', material.color));
+    } else {
+      inputs.push("".concat(pad, "color3f inputs:diffuseColor = ").concat(buildColor(material.color)));
+    }
+
+    if (material.emissiveMap !== null) {
+      inputs.push("".concat(pad, "color3f inputs:emissiveColor.connect = </Materials/Material_").concat(material.id, "/Texture_").concat(material.emissiveMap.id, "_emissive.outputs:rgb>"));
+      samplers.push(buildTexture(material.emissiveMap, 'emissive'));
+    } else if (material.emissive.getHex() > 0) {
+      inputs.push("".concat(pad, "color3f inputs:emissiveColor = ").concat(buildColor(material.emissive)));
+    }
+
+    if (material.normalMap !== null) {
+      inputs.push("".concat(pad, "normal3f inputs:normal.connect = </Materials/Material_").concat(material.id, "/Texture_").concat(material.normalMap.id, "_normal.outputs:rgb>"));
+      samplers.push(buildTexture(material.normalMap, 'normal'));
+    }
+
+    if (material.aoMap !== null) {
+      inputs.push("".concat(pad, "float inputs:occlusion.connect = </Materials/Material_").concat(material.id, "/Texture_").concat(material.aoMap.id, "_occlusion.outputs:r>"));
+      samplers.push(buildTexture(material.aoMap, 'occlusion'));
+    }
+
+    if (material.roughnessMap !== null && material.roughness === 1) {
+      inputs.push("".concat(pad, "float inputs:roughness.connect = </Materials/Material_").concat(material.id, "/Texture_").concat(material.roughnessMap.id, "_roughness.outputs:g>"));
+      samplers.push(buildTexture(material.roughnessMap, 'roughness'));
+    } else {
+      inputs.push("".concat(pad, "float inputs:roughness = ").concat(material.roughness));
+    }
+
+    if (material.metalnessMap !== null && material.metalness === 1) {
+      inputs.push("".concat(pad, "float inputs:metallic.connect = </Materials/Material_").concat(material.id, "/Texture_").concat(material.metalnessMap.id, "_metallic.outputs:b>"));
+      samplers.push(buildTexture(material.metalnessMap, 'metallic'));
+    } else {
+      inputs.push("".concat(pad, "float inputs:metallic = ").concat(material.metalness));
+    }
+
+    if (material.alphaMap !== null) {
+      inputs.push("".concat(pad, "float inputs:opacity.connect = </Materials/Material_").concat(material.id, "/Texture_").concat(material.alphaMap.id, "_opacity.outputs:r>"));
+      inputs.push("".concat(pad, "float inputs:opacityThreshold = 0.0001"));
+      samplers.push(buildTexture(material.alphaMap, 'opacity'));
+    } else {
+      inputs.push("".concat(pad, "float inputs:opacity = ").concat(material.opacity));
+    }
+
+    if (material.isMeshPhysicalMaterial) {
+      inputs.push("".concat(pad, "float inputs:clearcoat = ").concat(material.clearcoat));
+      inputs.push("".concat(pad, "float inputs:clearcoatRoughness = ").concat(material.clearcoatRoughness));
+      inputs.push("".concat(pad, "float inputs:ior = ").concat(material.ior));
+    }
+
+    return "\n    def Material \"Material_".concat(material.id, "\"\n    {\n        def Shader \"PreviewSurface\"\n        {\n            uniform token info:id = \"UsdPreviewSurface\"\n").concat(inputs.join('\n'), "\n            int inputs:useSpecularWorkflow = 0\n            token outputs:surface\n        }\n\n        token outputs:surface.connect = </Materials/Material_").concat(material.id, "/PreviewSurface.outputs:surface>\n        token inputs:frame:stPrimvarName = \"st\"\n\n        def Shader \"uvReader_st\"\n        {\n            uniform token info:id = \"UsdPrimvarReader_float2\"\n            token inputs:varname.connect = </Materials/Material_").concat(material.id, ".inputs:frame:stPrimvarName>\n            float2 inputs:fallback = (0.0, 0.0)\n            float2 outputs:result\n        }\n\n").concat(samplers.join('\n'), "\n\n    }\n");
+  }
+
+  function buildColor(color) {
+    return "(".concat(color.r, ", ").concat(color.g, ", ").concat(color.b, ")");
+  }
+
+  function buildVector2(vector) {
+    return "(".concat(vector.x, ", ").concat(vector.y, ")");
+  }
+});

data/lib-opal/js_wrap/three/geometries/BoxLineGeometry.js

@@ -0,0 +1,106 @@
+(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.BoxLineGeometry = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.BoxLineGeometry = void 0;
+
+  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; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var BoxLineGeometry = /*#__PURE__*/function (_BufferGeometry) {
+    _inherits(BoxLineGeometry, _BufferGeometry);
+
+    var _super = _createSuper(BoxLineGeometry);
+
+    function BoxLineGeometry() {
+      var _this;
+
+      var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      var widthSegments = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+      var heightSegments = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+      var depthSegments = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+
+      _classCallCheck(this, BoxLineGeometry);
+
+      _this = _super.call(this);
+      widthSegments = Math.floor(widthSegments);
+      heightSegments = Math.floor(heightSegments);
+      depthSegments = Math.floor(depthSegments);
+      var widthHalf = width / 2;
+      var heightHalf = height / 2;
+      var depthHalf = depth / 2;
+      var segmentWidth = width / widthSegments;
+      var segmentHeight = height / heightSegments;
+      var segmentDepth = depth / depthSegments;
+      var vertices = [];
+      var x = -widthHalf;
+      var y = -heightHalf;
+      var z = -depthHalf;
+
+      for (var i = 0; i <= widthSegments; i++) {
+        vertices.push(x, -heightHalf, -depthHalf, x, heightHalf, -depthHalf);
+        vertices.push(x, heightHalf, -depthHalf, x, heightHalf, depthHalf);
+        vertices.push(x, heightHalf, depthHalf, x, -heightHalf, depthHalf);
+        vertices.push(x, -heightHalf, depthHalf, x, -heightHalf, -depthHalf);
+        x += segmentWidth;
+      }
+
+      for (var _i = 0; _i <= heightSegments; _i++) {
+        vertices.push(-widthHalf, y, -depthHalf, widthHalf, y, -depthHalf);
+        vertices.push(widthHalf, y, -depthHalf, widthHalf, y, depthHalf);
+        vertices.push(widthHalf, y, depthHalf, -widthHalf, y, depthHalf);
+        vertices.push(-widthHalf, y, depthHalf, -widthHalf, y, -depthHalf);
+        y += segmentHeight;
+      }
+
+      for (var _i2 = 0; _i2 <= depthSegments; _i2++) {
+        vertices.push(-widthHalf, -heightHalf, z, -widthHalf, heightHalf, z);
+        vertices.push(-widthHalf, heightHalf, z, widthHalf, heightHalf, z);
+        vertices.push(widthHalf, heightHalf, z, widthHalf, -heightHalf, z);
+        vertices.push(widthHalf, -heightHalf, z, -widthHalf, -heightHalf, z);
+        z += segmentDepth;
+      }
+
+      _this.setAttribute('position', new _three.Float32BufferAttribute(vertices, 3));
+
+      return _this;
+    }
+
+    return _createClass(BoxLineGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.BoxLineGeometry = BoxLineGeometry;
+});

data/lib-opal/js_wrap/three/geometries/ConvexGeometry.js

@@ -0,0 +1,88 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../math/ConvexHull.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../math/ConvexHull.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.ConvexHull);
+    global.ConvexGeometry = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _ConvexHull) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ConvexGeometry = void 0;
+
+  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; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var ConvexGeometry = /*#__PURE__*/function (_BufferGeometry) {
+    _inherits(ConvexGeometry, _BufferGeometry);
+
+    var _super = _createSuper(ConvexGeometry);
+
+    function ConvexGeometry(points) {
+      var _this;
+
+      _classCallCheck(this, ConvexGeometry);
+
+      _this = _super.call(this); // buffers
+
+      var vertices = [];
+      var normals = [];
+
+      if (_ConvexHull.ConvexHull === undefined) {
+        console.error('THREE.ConvexBufferGeometry: ConvexBufferGeometry relies on ConvexHull');
+      }
+
+      var convexHull = new _ConvexHull.ConvexHull().setFromPoints(points); // generate vertices and normals
+
+      var faces = convexHull.faces;
+
+      for (var i = 0; i < faces.length; i++) {
+        var face = faces[i];
+        var edge = face.edge; // we move along a doubly-connected edge list to access all face points (see HalfEdge docs)
+
+        do {
+          var point = edge.head().point;
+          vertices.push(point.x, point.y, point.z);
+          normals.push(face.normal.x, face.normal.y, face.normal.z);
+          edge = edge.next;
+        } while (edge !== face.edge);
+      } // build geometry
+
+
+      _this.setAttribute('position', new _three.Float32BufferAttribute(vertices, 3));
+
+      _this.setAttribute('normal', new _three.Float32BufferAttribute(normals, 3));
+
+      return _this;
+    }
+
+    return _createClass(ConvexGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.ConvexGeometry = ConvexGeometry;
+});