opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/webxr/XREstimatedLight.js

@@ -0,0 +1,221 @@
+(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.XREstimatedLight = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.XREstimatedLight = void 0;
+
+  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); }
+
+  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 SessionLightProbe = /*#__PURE__*/function () {
+    function SessionLightProbe(xrLight, renderer, lightProbe, environmentEstimation, estimationStartCallback) {
+      var _this = this;
+
+      _classCallCheck(this, SessionLightProbe);
+
+      this.xrLight = xrLight;
+      this.renderer = renderer;
+      this.lightProbe = lightProbe;
+      this.xrWebGLBinding = null;
+      this.estimationStartCallback = estimationStartCallback;
+      this.frameCallback = this.onXRFrame.bind(this);
+      var session = renderer.xr.getSession(); // If the XRWebGLBinding class is available then we can also query an
+      // estimated reflection cube map.
+
+      if (environmentEstimation && 'XRWebGLBinding' in window) {
+        // This is the simplest way I know of to initialize a WebGL cubemap in Three.
+        var cubeRenderTarget = new _three.WebGLCubeRenderTarget(16);
+        xrLight.environment = cubeRenderTarget.texture;
+        var gl = renderer.getContext(); // Ensure that we have any extensions needed to use the preferred cube map format.
+
+        switch (session.preferredReflectionFormat) {
+          case 'srgba8':
+            gl.getExtension('EXT_sRGB');
+            break;
+
+          case 'rgba16f':
+            gl.getExtension('OES_texture_half_float');
+            break;
+        }
+
+        this.xrWebGLBinding = new XRWebGLBinding(session, gl);
+        this.lightProbe.addEventListener('reflectionchange', function () {
+          _this.updateReflection();
+        });
+      } // Start monitoring the XR animation frame loop to look for lighting
+      // estimation changes.
+
+
+      session.requestAnimationFrame(this.frameCallback);
+    }
+
+    _createClass(SessionLightProbe, [{
+      key: "updateReflection",
+      value: function updateReflection() {
+        var textureProperties = this.renderer.properties.get(this.xrLight.environment);
+
+        if (textureProperties) {
+          var cubeMap = this.xrWebGLBinding.getReflectionCubeMap(this.lightProbe);
+
+          if (cubeMap) {
+            textureProperties.__webglTexture = cubeMap;
+          }
+        }
+      }
+    }, {
+      key: "onXRFrame",
+      value: function onXRFrame(time, xrFrame) {
+        // If either this obejct or the XREstimatedLight has been destroyed, stop
+        // running the frame loop.
+        if (!this.xrLight) {
+          return;
+        }
+
+        var session = xrFrame.session;
+        session.requestAnimationFrame(this.frameCallback);
+        var lightEstimate = xrFrame.getLightEstimate(this.lightProbe);
+
+        if (lightEstimate) {
+          // We can copy the estimate's spherical harmonics array directly into the light probe.
+          this.xrLight.lightProbe.sh.fromArray(lightEstimate.sphericalHarmonicsCoefficients);
+          this.xrLight.lightProbe.intensity = 1.0; // For the directional light we have to normalize the color and set the scalar as the
+          // intensity, since WebXR can return color values that exceed 1.0.
+
+          var intensityScalar = Math.max(1.0, Math.max(lightEstimate.primaryLightIntensity.x, Math.max(lightEstimate.primaryLightIntensity.y, lightEstimate.primaryLightIntensity.z)));
+          this.xrLight.directionalLight.color.setRGB(lightEstimate.primaryLightIntensity.x / intensityScalar, lightEstimate.primaryLightIntensity.y / intensityScalar, lightEstimate.primaryLightIntensity.z / intensityScalar);
+          this.xrLight.directionalLight.intensity = intensityScalar;
+          this.xrLight.directionalLight.position.copy(lightEstimate.primaryLightDirection);
+
+          if (this.estimationStartCallback) {
+            this.estimationStartCallback();
+            this.estimationStartCallback = null;
+          }
+        }
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        this.xrLight = null;
+        this.renderer = null;
+        this.lightProbe = null;
+        this.xrWebGLBinding = null;
+      }
+    }]);
+
+    return SessionLightProbe;
+  }();
+
+  var XREstimatedLight = /*#__PURE__*/function (_Group) {
+    _inherits(XREstimatedLight, _Group);
+
+    var _super = _createSuper(XREstimatedLight);
+
+    function XREstimatedLight(renderer) {
+      var _this2;
+
+      var environmentEstimation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+      _classCallCheck(this, XREstimatedLight);
+
+      _this2 = _super.call(this);
+      _this2.lightProbe = new _three.LightProbe();
+      _this2.lightProbe.intensity = 0;
+
+      _this2.add(_this2.lightProbe);
+
+      _this2.directionalLight = new _three.DirectionalLight();
+      _this2.directionalLight.intensity = 0;
+
+      _this2.add(_this2.directionalLight); // Will be set to a cube map in the SessionLightProbe is environment estimation is
+      // available and requested.
+
+
+      _this2.environment = null;
+      var sessionLightProbe = null;
+      var estimationStarted = false;
+      renderer.xr.addEventListener('sessionstart', function () {
+        var session = renderer.xr.getSession();
+
+        if ('requestLightProbe' in session) {
+          session.requestLightProbe({
+            reflectionFormat: session.preferredReflectionFormat
+          }).then(function (probe) {
+            sessionLightProbe = new SessionLightProbe(_assertThisInitialized(_this2), renderer, probe, environmentEstimation, function () {
+              estimationStarted = true; // Fired to indicate that the estimated lighting values are now being updated.
+
+              _this2.dispatchEvent({
+                type: 'estimationstart'
+              });
+            });
+          });
+        }
+      });
+      renderer.xr.addEventListener('sessionend', function () {
+        if (sessionLightProbe) {
+          sessionLightProbe.dispose();
+          sessionLightProbe = null;
+        }
+
+        if (estimationStarted) {
+          // Fired to indicate that the estimated lighting values are no longer being updated.
+          _this2.dispatchEvent({
+            type: 'estimationend'
+          });
+        }
+      }); // Done inline to provide access to sessionLightProbe.
+
+      _this2.dispose = function () {
+        if (sessionLightProbe) {
+          sessionLightProbe.dispose();
+          sessionLightProbe = null;
+        }
+
+        _this2.remove(_this2.lightProbe);
+
+        _this2.lightProbe = null;
+
+        _this2.remove(_this2.directionalLight);
+
+        _this2.directionalLight = null;
+        _this2.environment = null;
+      };
+
+      return _this2;
+    }
+
+    return _createClass(XREstimatedLight);
+  }(_three.Group);
+
+  _exports.XREstimatedLight = XREstimatedLight;
+});

data/lib-opal/js_wrap/three/webxr/XRHandMeshModel.js

@@ -0,0 +1,93 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../loaders/GLTFLoader.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../loaders/GLTFLoader.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.GLTFLoader);
+    global.XRHandMeshModel = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _GLTFLoader) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.XRHandMeshModel = 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 DEFAULT_HAND_PROFILE_PATH = 'https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles/generic-hand/';
+
+  var XRHandMeshModel = /*#__PURE__*/function () {
+    function XRHandMeshModel(handModel, controller, path, handedness) {
+      var _this = this;
+
+      _classCallCheck(this, XRHandMeshModel);
+
+      this.controller = controller;
+      this.handModel = handModel;
+      this.bones = [];
+      var loader = new _GLTFLoader.GLTFLoader();
+      loader.setPath(path || DEFAULT_HAND_PROFILE_PATH);
+      loader.load("".concat(handedness, ".glb"), function (gltf) {
+        var object = gltf.scene.children[0];
+
+        _this.handModel.add(object);
+
+        var mesh = object.getObjectByProperty('type', 'SkinnedMesh');
+        mesh.frustumCulled = false;
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        var joints = ['wrist', 'thumb-metacarpal', 'thumb-phalanx-proximal', 'thumb-phalanx-distal', 'thumb-tip', 'index-finger-metacarpal', 'index-finger-phalanx-proximal', 'index-finger-phalanx-intermediate', 'index-finger-phalanx-distal', 'index-finger-tip', 'middle-finger-metacarpal', 'middle-finger-phalanx-proximal', 'middle-finger-phalanx-intermediate', 'middle-finger-phalanx-distal', 'middle-finger-tip', 'ring-finger-metacarpal', 'ring-finger-phalanx-proximal', 'ring-finger-phalanx-intermediate', 'ring-finger-phalanx-distal', 'ring-finger-tip', 'pinky-finger-metacarpal', 'pinky-finger-phalanx-proximal', 'pinky-finger-phalanx-intermediate', 'pinky-finger-phalanx-distal', 'pinky-finger-tip'];
+        joints.forEach(function (jointName) {
+          var bone = object.getObjectByName(jointName);
+
+          if (bone !== undefined) {
+            bone.jointName = jointName;
+          } else {
+            console.warn("Couldn't find ".concat(jointName, " in ").concat(handedness, " hand mesh"));
+          }
+
+          _this.bones.push(bone);
+        });
+      });
+    }
+
+    _createClass(XRHandMeshModel, [{
+      key: "updateMesh",
+      value: function updateMesh() {
+        // XR Joints
+        var XRJoints = this.controller.joints;
+
+        for (var i = 0; i < this.bones.length; i++) {
+          var bone = this.bones[i];
+
+          if (bone) {
+            var XRJoint = XRJoints[bone.jointName];
+
+            if (XRJoint.visible) {
+              var position = XRJoint.position;
+
+              if (bone) {
+                bone.position.copy(position);
+                bone.quaternion.copy(XRJoint.quaternion); // bone.scale.setScalar( XRJoint.jointRadius || defaultRadius );
+              }
+            }
+          }
+        }
+      }
+    }]);
+
+    return XRHandMeshModel;
+  }();
+
+  _exports.XRHandMeshModel = XRHandMeshModel;
+});

data/lib-opal/js_wrap/three/webxr/XRHandModelFactory.js

@@ -0,0 +1,127 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./XRHandPrimitiveModel.js", "./XRHandMeshModel.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./XRHandPrimitiveModel.js"), require("./XRHandMeshModel.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.XRHandPrimitiveModel, global.XRHandMeshModel);
+    global.XRHandModelFactory = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _XRHandPrimitiveModel, _XRHandMeshModel) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.XRHandModelFactory = 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; }
+
+  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  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 XRHandModel = /*#__PURE__*/function (_Object3D) {
+    _inherits(XRHandModel, _Object3D);
+
+    var _super = _createSuper(XRHandModel);
+
+    function XRHandModel(controller) {
+      var _this;
+
+      _classCallCheck(this, XRHandModel);
+
+      _this = _super.call(this);
+      _this.controller = controller;
+      _this.motionController = null;
+      _this.envMap = null;
+      _this.mesh = null;
+      return _this;
+    }
+
+    _createClass(XRHandModel, [{
+      key: "updateMatrixWorld",
+      value: function updateMatrixWorld(force) {
+        _get(_getPrototypeOf(XRHandModel.prototype), "updateMatrixWorld", this).call(this, force);
+
+        if (this.motionController) {
+          this.motionController.updateMesh();
+        }
+      }
+    }]);
+
+    return XRHandModel;
+  }(_three.Object3D);
+
+  var XRHandModelFactory = /*#__PURE__*/function () {
+    function XRHandModelFactory() {
+      _classCallCheck(this, XRHandModelFactory);
+
+      this.path = null;
+    }
+
+    _createClass(XRHandModelFactory, [{
+      key: "setPath",
+      value: function setPath(path) {
+        this.path = path;
+        return this;
+      }
+    }, {
+      key: "createHandModel",
+      value: function createHandModel(controller, profile) {
+        var _this2 = this;
+
+        var handModel = new XRHandModel(controller);
+        controller.addEventListener('connected', function (event) {
+          var xrInputSource = event.data;
+
+          if (xrInputSource.hand && !handModel.motionController) {
+            handModel.xrInputSource = xrInputSource; // @todo Detect profile if not provided
+
+            if (profile === undefined || profile === 'spheres') {
+              handModel.motionController = new _XRHandPrimitiveModel.XRHandPrimitiveModel(handModel, controller, _this2.path, xrInputSource.handedness, {
+                primitive: 'sphere'
+              });
+            } else if (profile === 'boxes') {
+              handModel.motionController = new _XRHandPrimitiveModel.XRHandPrimitiveModel(handModel, controller, _this2.path, xrInputSource.handedness, {
+                primitive: 'box'
+              });
+            } else if (profile === 'mesh') {
+              handModel.motionController = new _XRHandMeshModel.XRHandMeshModel(handModel, controller, _this2.path, xrInputSource.handedness);
+            }
+          }
+        });
+        controller.addEventListener('disconnected', function () {// handModel.motionController = null;
+          // handModel.remove( scene );
+          // scene = null;
+        });
+        return handModel;
+      }
+    }]);
+
+    return XRHandModelFactory;
+  }();
+
+  _exports.XRHandModelFactory = XRHandModelFactory;
+});

data/lib-opal/js_wrap/three/webxr/XRHandPrimitiveModel.js

@@ -0,0 +1,85 @@
+(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.XRHandPrimitiveModel = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.XRHandPrimitiveModel = 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 _matrix = new _three.Matrix4();
+
+  var _vector = new _three.Vector3();
+
+  var XRHandPrimitiveModel = /*#__PURE__*/function () {
+    function XRHandPrimitiveModel(handModel, controller, path, handedness, options) {
+      _classCallCheck(this, XRHandPrimitiveModel);
+
+      this.controller = controller;
+      this.handModel = handModel;
+      this.envMap = null;
+      var geometry;
+
+      if (!options || !options.primitive || options.primitive === 'sphere') {
+        geometry = new _three.SphereGeometry(1, 10, 10);
+      } else if (options.primitive === 'box') {
+        geometry = new _three.BoxGeometry(1, 1, 1);
+      }
+
+      var material = new _three.MeshStandardMaterial();
+      this.handMesh = new _three.InstancedMesh(geometry, material, 30);
+      this.handMesh.instanceMatrix.setUsage(_three.DynamicDrawUsage); // will be updated every frame
+
+      this.handMesh.castShadow = true;
+      this.handMesh.receiveShadow = true;
+      this.handModel.add(this.handMesh);
+      this.joints = ['wrist', 'thumb-metacarpal', 'thumb-phalanx-proximal', 'thumb-phalanx-distal', 'thumb-tip', 'index-finger-metacarpal', 'index-finger-phalanx-proximal', 'index-finger-phalanx-intermediate', 'index-finger-phalanx-distal', 'index-finger-tip', 'middle-finger-metacarpal', 'middle-finger-phalanx-proximal', 'middle-finger-phalanx-intermediate', 'middle-finger-phalanx-distal', 'middle-finger-tip', 'ring-finger-metacarpal', 'ring-finger-phalanx-proximal', 'ring-finger-phalanx-intermediate', 'ring-finger-phalanx-distal', 'ring-finger-tip', 'pinky-finger-metacarpal', 'pinky-finger-phalanx-proximal', 'pinky-finger-phalanx-intermediate', 'pinky-finger-phalanx-distal', 'pinky-finger-tip'];
+    }
+
+    _createClass(XRHandPrimitiveModel, [{
+      key: "updateMesh",
+      value: function updateMesh() {
+        var defaultRadius = 0.008;
+        var joints = this.controller.joints;
+        var count = 0;
+
+        for (var i = 0; i < this.joints.length; i++) {
+          var joint = joints[this.joints[i]];
+
+          if (joint.visible) {
+            _vector.setScalar(joint.jointRadius || defaultRadius);
+
+            _matrix.compose(joint.position, joint.quaternion, _vector);
+
+            this.handMesh.setMatrixAt(i, _matrix);
+            count++;
+          }
+        }
+
+        this.handMesh.count = count;
+        this.handMesh.instanceMatrix.needsUpdate = true;
+      }
+    }]);
+
+    return XRHandPrimitiveModel;
+  }();
+
+  _exports.XRHandPrimitiveModel = XRHandPrimitiveModel;
+});

data/opal-js_wrap-three.gemspec

@@ -10,20 +10,20 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "Wrapper for Three.js"
   spec.description   = "(Mostly) raw wrapper for the Three.js library for Opal"
-  spec.homepage      = "https://github.com/hmdne/opal-jswrap-three"
+  spec.homepage      = "https://github.com/hmdne/opal-js_wrap-three"
   spec.license       = "MIT"
   spec.required_ruby_version = ">= 2.6.0"
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/hmdne/opal-jswrap-three"
-  spec.metadata["changelog_uri"] = "https://github.com/hmdne/opal-jswrap-three/blob/CHANGELOG.md"
+  spec.metadata["source_code_uri"] = "https://github.com/hmdne/opal-js_wrap-three"
+  spec.metadata["changelog_uri"] = "https://github.com/hmdne/opal-js_wrap-three/blob/master/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    ["lib-opal/js_wrap/three/three.js"] + `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+    Dir["lib-opal/js_wrap/three/**/*.js"] + `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }