From ee427ccca4e0f326987002b9538623554f2897fc Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 2 Oct 2019 06:25:07 -0400 Subject: [PATCH 001/562] Add initial RiggedModel hack, not accurate or good as a basis for anything --- app.html | 184 +++++++++++++------------------------------------------ 1 file changed, 42 insertions(+), 142 deletions(-) diff --git a/app.html b/app.html index 4241cb1..cb11323 100644 --- a/app.html +++ b/app.html @@ -352,6 +352,22 @@ subtree: true, }); +class RiggedModel { + constructor(avatarMesh) { + this.avatarMesh = avatarMesh; + } + setState(hmd, gamepads) { + this.avatarMesh.position.fromArray(hmd.position).sub(localVector.set(0, 1.5, 0)); + localQuaternion.fromArray(hmd.quaternion); + localEuler.setFromQuaternion(localQuaternion, localEuler.order); + localEuler.y += Math.PI; + localEuler.x *= -1; + this.avatarMesh.quaternion.setFromEuler(localEuler); + } + update() { + // console.log('per-frame update called'); + } +} const _makePeerConnection = peerConnectionId => { const peerConnectionConfig = { iceServers: [ @@ -365,7 +381,7 @@ console.log('got track', e); }; - let skinMesh = null; + let avatarMesh = null; const sendChannel = peerConnection.createDataChannel('sendChannel'); peerConnection.sendChannel = sendChannel; let pingInterval = 0; @@ -373,9 +389,19 @@ sendChannel.onopen = () => { // console.log('data channel local open'); - skinMesh = _makeSkinMesh(); - skinMesh.setSkinUrl(DEFAULT_SKIN_URL); - skinMeshes.push(skinMesh); + avatarMesh = new THREE.Object3D(); + avatarMesh.riggedModel = null; + const loader = new THREE.GLTFLoader(); + loader.load('https://modulesio.github.io/models/miku.glb', object => { + if (avatarMesh) { + avatarMesh.riggedModel = new RiggedModel(object.scene); + avatarMesh.add(object.scene); + } + }, xhr => {}, err => { + console.warn(err); + }); + scene.add(avatarMesh); + avatarMeshes.push(avatarMesh); peerConnection.open = true; @@ -459,9 +485,9 @@ const data = JSON.parse(e.data); const {method} = data; if (method === 'pose') { - if (skinMesh) { + if (avatarMesh && avatarMesh.riggedModel) { const {hmd, gamepads} = data; - skinMesh.setState(hmd, gamepads); + avatarMesh.riggedModel.setState(hmd, gamepads); } } else if (landState && method === 'initState') { const {state} = data; @@ -507,10 +533,10 @@ if (index !== -1) { peerConnections.splice(index, 1); } - if (skinMesh) { - skinMesh.destroy(); - skinMeshes.splice(skinMeshes.indexOf(skinMesh), 1); - skinMesh = null; + if (avatarMesh) { + scene.remove(avatarMesh); + avatarMeshes.splice(avatarMeshes.indexOf(avatarMesh), 1); + avatarMesh = null; } if (landState) { // remove owned xr-iframes @@ -6095,12 +6121,13 @@ }; _updateSceneMeshes(); */ - const _updateSkinMeshes = () => { - for (let i = 0; i < skinMeshes.length; i++) { - skinMeshes[i].update(); + const _updateAvatarMeshes = () => { + for (let i = 0; i < avatarMeshes.length; i++) { + const avatarMesh = avatarMeshes[i]; + avatarMesh.riggedModel && avatarMesh.riggedModel.update(); } }; - _updateSkinMeshes(); + _updateAvatarMeshes(); const _handleTrigger = (gamepad, i, pressed, lastPressed) => { const start = pressed && !lastPressed; @@ -6870,139 +6897,12 @@ console.warn(err.stack); }); -const skinMeshes = []; +const avatarMeshes = []; const _mod = (v, d) => { const n = v % d; return n < 0 ? (d + n) : n; }; const _angleDiff = (a, b) => _mod((b - a) + Math.PI, Math.PI * 2) - Math.PI; -const _makeSkinMesh = () => { - const object = {}; - let onsetstate = null; - const uniforms = THREE.UniformsUtils.clone(skin.SKIN_SHADER.uniforms); - object.setSkinUrl = skinUrl => { - if (skinUrl) { - const mesh = skin({ - limbs: true, - }); - mesh.frustumCulled = false; - - mesh.onBeforeRender = (onBeforeRender => function() { - mesh.material.uniforms.headRotation.value.copy(uniforms.headRotation.value); - mesh.material.uniforms.leftArmRotation.value.copy(uniforms.leftArmRotation.value); - mesh.material.uniforms.rightArmRotation.value.copy(uniforms.rightArmRotation.value); - mesh.material.uniforms.theta.value = uniforms.theta.value; - mesh.material.uniforms.headVisible.value = uniforms.headVisible.value; - mesh.material.uniforms.hit.value = uniforms.hit.value; - - onBeforeRender.apply(this, arguments); - })(mesh.onBeforeRender); - - return new Promise((accept, reject) => { - const skinImg = new Image(); - skinImg.crossOrigin = 'Anonymous'; - skinImg.src = skinUrl; - skinImg.onload = () => { - accept(skinImg); - }; - skinImg.onerror = err => { - reject(err); - }; - }) - .then(skinImg => { - mesh.setImage(skinImg); - - onsetstate = (hmd, gamepads) => { - const hmdPosition = localVector.fromArray(hmd.position); - const hmdQuaternion = localQuaternion.fromArray(hmd.quaternion); - - const hmdEuler = localEuler.setFromQuaternion(hmdQuaternion, localEuler.order); - const playerEuler = localEuler2.setFromQuaternion(mesh.quaternion, localEuler2.order); - const angleDiff = _angleDiff(hmdEuler.y, playerEuler.y); - const angleDiffAbs = Math.abs(angleDiff); - if (angleDiffAbs > Math.PI / 2) { - playerEuler.y += (angleDiffAbs - (Math.PI / 2)) * (angleDiff < 0 ? 1 : -1); - mesh.quaternion.setFromEuler(playerEuler); - } - - const oldWorldPosition = mesh.getWorldPosition(localVector2); - mesh.position.copy(hmdPosition) - .sub(mesh.eye.getWorldPosition(localVector3)) - .add(oldWorldPosition); - - const playerQuaternionInverse = localQuaternion2.copy(mesh.quaternion).inverse(); - mesh.head.quaternion.copy(playerQuaternionInverse).multiply(hmdQuaternion); - mesh.updateMatrixWorld(); - - const headQuaternionInverse = localQuaternion3.copy(mesh.head.quaternion).inverse(); - uniforms.headRotation.value.set(headQuaternionInverse.x, headQuaternionInverse.y, headQuaternionInverse.z, headQuaternionInverse.w); - - for (let i = 0; i < 2; i++) { - const armRotation = uniforms[i === 0 ? 'leftArmRotation' : 'rightArmRotation']; - - const gamepad = gamepads[i]; - if (gamepad.visible) { - const gamepadPosition = localVector.fromArray(gamepad.position); - const gamepadQuaternion = localQuaternion.fromArray(gamepad.quaternion); - - const armQuaternionInverse = localQuaternion3.setFromRotationMatrix( - localMatrix.lookAt( - mesh.arms[i === 0 ? 'left' : 'right'] - .getWorldPosition(localVector2), - gamepadPosition, - localVector3 - .set(0, 1, 0) - .applyQuaternion(gamepadQuaternion) - ) - ) - .multiply(armQuaternionOffset) - .premultiply(playerQuaternionInverse) - .inverse(); - armRotation.value.set(armQuaternionInverse.x, armQuaternionInverse.y, armQuaternionInverse.z, armQuaternionInverse.w); - // console.log('arm rotation', i, armRotation.value.toArray().join(',')); - } else { - armRotation.value.set(0, 0, 0, 1); - } - } - }; - - if (object.skinMesh) { - object.skinMesh.parent.remove(object.skinMesh); - object.skinMesh = null; - } - - scene.add(mesh); - object.skinMesh = mesh; - }); - } else { - onsetstate = null; - - if (object.skinMesh) { - object.skinMesh.parent.remove(object.skinMesh); - object.skinMesh = null; - } - } - }; - object.setState = (hmd, gamepads) => { - onsetstate && onsetstate(hmd, gamepads); - }; - object.animate = thetaValue => { - uniforms.theta.value = thetaValue; - }; - object.update = () => { - // XXX - }; - object.destroy = () => { - onsetstate = null; - - if (object.skinMesh) { - object.skinMesh.parent.remove(object.skinMesh); - object.skinMesh = null; - } - }; - object.skinMesh = null; - return object; -}; scene.add(defaultGltf); const _loadDefaultGltf = () => { From a312df693e321b9e501ba49f8eb17cd8cc33656a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 9 Oct 2019 00:19:28 -0400 Subject: [PATCH 002/562] Add three-ik.js --- three-ik.js | 1183 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1183 insertions(+) create mode 100644 three-ik.js diff --git a/three-ik.js b/three-ik.js new file mode 100644 index 0000000..5af851c --- /dev/null +++ b/three-ik.js @@ -0,0 +1,1183 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('three')) : + typeof define === 'function' && define.amd ? define(['exports', 'three'], factory) : + (factory((global.IK = {}),global.THREE)); +}(this, (function (exports,three) { 'use strict'; + +var t1 = new three.Vector3(); +var t2 = new three.Vector3(); +var t3 = new three.Vector3(); +var m1 = new three.Matrix4(); +function getWorldPosition(object, target) { + return target.setFromMatrixPosition(object.matrixWorld); +} + +function getCentroid(positions, target) { + target.set(0, 0, 0); + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + try { + for (var _iterator = positions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var position = _step.value; + target.add(position); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + target.divideScalar(positions.length); + return target; +} +function setQuaternionFromDirection(direction, up, target) { + var x = t1; + var y = t2; + var z = t3; + var m = m1; + var el = m1.elements; + z.copy(direction); + x.crossVectors(up, z); + if (x.lengthSq() === 0) { + if (Math.abs(up.z) === 1) { + z.x += 0.0001; + } else { + z.z += 0.0001; + } + z.normalize(); + x.crossVectors(up, z); + } + x.normalize(); + y.crossVectors(z, x); + el[0] = x.x;el[4] = y.x;el[8] = z.x; + el[1] = x.y;el[5] = y.y;el[9] = z.y; + el[2] = x.z;el[6] = y.z;el[10] = z.z; + target.setFromRotationMatrix(m); +} +function transformPoint(vector, matrix, target) { + var e = matrix.elements; + var x = vector.x * e[0] + vector.y * e[4] + vector.z * e[8] + e[12]; + var y = vector.x * e[1] + vector.y * e[5] + vector.z * e[9] + e[13]; + var z = vector.x * e[2] + vector.y * e[6] + vector.z * e[10] + e[14]; + var w = vector.x * e[3] + vector.y * e[7] + vector.z * e[11] + e[15]; + target.set(x / w, y / w, z / w); +} + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { + return typeof obj; +} : function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; +}; + + + + + +var asyncGenerator = function () { + function AwaitValue(value) { + this.value = value; + } + + function AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + + if (value instanceof AwaitValue) { + Promise.resolve(value.value).then(function (arg) { + resume("next", arg); + }, function (arg) { + resume("throw", arg); + }); + } else { + settle(result.done ? "return" : "normal", result.value); + } + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + return { + wrap: function (fn) { + return function () { + return new AsyncGenerator(fn.apply(this, arguments)); + }; + }, + await: function (value) { + return new AwaitValue(value); + } + }; +}(); + + + + + +var classCallCheck = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +}; + +var createClass = 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); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; +}(); + + + + + + + +var get = function get(object, property, receiver) { + if (object === null) object = Function.prototype; + var desc = Object.getOwnPropertyDescriptor(object, property); + + if (desc === undefined) { + var parent = Object.getPrototypeOf(object); + + if (parent === null) { + return undefined; + } else { + return get(parent, property, receiver); + } + } else if ("value" in desc) { + return desc.value; + } else { + var getter = desc.get; + + if (getter === undefined) { + return undefined; + } + + return getter.call(receiver); + } +}; + +var inherits = function (subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; +}; + + + + + + + + + + + +var possibleConstructorReturn = function (self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; +}; + + + + + +var slicedToArray = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; +}(); + +var Z_AXIS = new three.Vector3(0, 0, 1); +var DEG2RAD = three.Math.DEG2RAD; +var RAD2DEG = three.Math.RAD2DEG; +var IKBallConstraint = function () { + function IKBallConstraint(angle) { + classCallCheck(this, IKBallConstraint); + this.angle = angle; + } + createClass(IKBallConstraint, [{ + key: '_apply', + value: function _apply(joint) { + var direction = new three.Vector3().copy(joint._getDirection()); + var parentDirection = joint._localToWorldDirection(new three.Vector3().copy(Z_AXIS)).normalize(); + var currentAngle = direction.angleTo(parentDirection) * RAD2DEG; + if (this.angle / 2 < currentAngle) { + direction.normalize(); + var correctionAxis = new three.Vector3().crossVectors(parentDirection, direction).normalize(); + parentDirection.applyAxisAngle(correctionAxis, this.angle * DEG2RAD * 0.5); + joint._setDirection(parentDirection); + return true; + } + return false; + } + }]); + return IKBallConstraint; +}(); + +var Y_AXIS = new three.Vector3(0, 1, 0); +var IKJoint = function () { + function IKJoint(bone) { + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + constraints = _ref.constraints; + classCallCheck(this, IKJoint); + this.constraints = constraints || []; + this.bone = bone; + this.distance = 0; + this._originalDirection = new three.Vector3(); + this._direction = new three.Vector3(); + this._worldPosition = new three.Vector3(); + this._isSubBase = false; + this._subBasePositions = null; + this.isIKJoint = true; + this._updateWorldPosition(); + } + createClass(IKJoint, [{ + key: '_setIsSubBase', + value: function _setIsSubBase() { + this._isSubBase = true; + this._subBasePositions = []; + } + }, { + key: '_applySubBasePositions', + value: function _applySubBasePositions() { + if (this._subBasePositions.length === 0) { + return; + } + getCentroid(this._subBasePositions, this._worldPosition); + this._subBasePositions.length = 0; + } + }, { + key: '_applyConstraints', + value: function _applyConstraints() { + if (!this.constraints) { + return; + } + var constraintApplied = false; + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + try { + for (var _iterator = this.constraints[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var constraint = _step.value; + if (constraint && constraint._apply) { + var applied = constraint._apply(this); + constraintApplied = constraintApplied || applied; + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + return constraintApplied; + } + }, { + key: '_setDistance', + value: function _setDistance(distance) { + this.distance = distance; + } + }, { + key: '_getDirection', + value: function _getDirection() { + return this._direction; + } + }, { + key: '_setDirection', + value: function _setDirection(direction) { + this._direction.copy(direction); + } + }, { + key: '_getDistance', + value: function _getDistance() { + return this.distance; + } + }, { + key: '_updateMatrixWorld', + value: function _updateMatrixWorld() { + this.bone.updateMatrixWorld(true); + } + }, { + key: '_getWorldPosition', + value: function _getWorldPosition() { + return this._worldPosition; + } + }, { + key: '_getWorldDirection', + value: function _getWorldDirection(joint) { + return new three.Vector3().subVectors(this._getWorldPosition(), joint._getWorldPosition()).normalize(); + } + }, { + key: '_updateWorldPosition', + value: function _updateWorldPosition() { + getWorldPosition(this.bone, this._worldPosition); + } + }, { + key: '_setWorldPosition', + value: function _setWorldPosition(position) { + this._worldPosition.copy(position); + } + }, { + key: '_localToWorldDirection', + value: function _localToWorldDirection(direction) { + if (this.bone.parent) { + var parent = this.bone.parent.matrixWorld; + direction.transformDirection(parent); + } + return direction; + } + }, { + key: '_worldToLocalDirection', + value: function _worldToLocalDirection(direction) { + if (this.bone.parent) { + var inverseParent = new three.Matrix4().getInverse(this.bone.parent.matrixWorld); + direction.transformDirection(inverseParent); + } + return direction; + } + }, { + key: '_applyWorldPosition', + value: function _applyWorldPosition() { + var direction = new three.Vector3().copy(this._direction); + var position = new three.Vector3().copy(this._getWorldPosition()); + var parent = this.bone.parent; + if (parent) { + this._updateMatrixWorld(); + var inverseParent = new three.Matrix4().getInverse(this.bone.parent.matrixWorld); + transformPoint(position, inverseParent, position); + this.bone.position.copy(position); + this._updateMatrixWorld(); + this._worldToLocalDirection(direction); + setQuaternionFromDirection(direction, Y_AXIS, this.bone.quaternion); + } else { + this.bone.position.copy(position); + } + this.bone.updateMatrix(); + this._updateMatrixWorld(); + } + }, { + key: '_getWorldDistance', + value: function _getWorldDistance(joint) { + return this._worldPosition.distanceTo(joint.isIKJoint ? joint._getWorldPosition() : getWorldPosition(joint, new three.Vector3())); + } + }]); + return IKJoint; +}(); + +var IKChain = function () { + function IKChain() { + classCallCheck(this, IKChain); + this.isIKChain = true; + this.totalLengths = 0; + this.base = null; + this.effector = null; + this.effectorIndex = null; + this.chains = new Map(); + this.origin = null; + this.iterations = 100; + this.tolerance = 0.01; + this._depth = -1; + this._targetPosition = new three.Vector3(); + } + createClass(IKChain, [{ + key: 'add', + value: function add(joint) { + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + target = _ref.target; + if (this.effector) { + throw new Error('Cannot add additional joints to a chain with an end effector.'); + } + if (!joint.isIKJoint) { + if (joint.isBone) { + joint = new IKJoint(joint); + } else { + throw new Error('Invalid joint in an IKChain. Must be an IKJoint or a THREE.Bone.'); + } + } + this.joints = this.joints || []; + this.joints.push(joint); + if (this.joints.length === 1) { + this.base = this.joints[0]; + this.origin = new three.Vector3().copy(this.base._getWorldPosition()); + } + else { + var previousJoint = this.joints[this.joints.length - 2]; + previousJoint._updateMatrixWorld(); + previousJoint._updateWorldPosition(); + joint._updateWorldPosition(); + var distance = previousJoint._getWorldDistance(joint); + if (distance === 0) { + throw new Error('bone with 0 distance between adjacent bone found'); + } + joint._setDistance(distance); + joint._updateWorldPosition(); + var direction = previousJoint._getWorldDirection(joint); + previousJoint._originalDirection = new three.Vector3().copy(direction); + joint._originalDirection = new three.Vector3().copy(direction); + this.totalLengths += distance; + } + if (target) { + this.effector = joint; + this.effectorIndex = joint; + this.target = target; + } + return this; + } + }, { + key: '_hasEffector', + value: function _hasEffector() { + return !!this.effector; + } + }, { + key: '_getDistanceFromTarget', + value: function _getDistanceFromTarget() { + return this._hasEffector() ? this.effector._getWorldDistance(this.target) : -1; + } + }, { + key: 'connect', + value: function connect(chain) { + if (!chain.isIKChain) { + throw new Error('Invalid connection in an IKChain. Must be an IKChain.'); + } + if (!chain.base.isIKJoint) { + throw new Error('Connecting chain does not have a base joint.'); + } + var index = this.joints.indexOf(chain.base); + if (this.target && index === this.joints.length - 1) { + throw new Error('Cannot append a chain to an end joint in a chain with a target.'); + } + if (index === -1) { + throw new Error('Cannot connect chain that does not have a base joint in parent chain.'); + } + this.joints[index]._setIsSubBase(); + var chains = this.chains.get(index); + if (!chains) { + chains = []; + this.chains.set(index, chains); + } + chains.push(chain); + return this; + } + }, { + key: '_updateJointWorldPositions', + value: function _updateJointWorldPositions() { + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + try { + for (var _iterator = this.joints[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var joint = _step.value; + joint._updateWorldPosition(); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + } + }, { + key: '_forward', + value: function _forward() { + this.origin.copy(this.base._getWorldPosition()); + if (this.target) { + this._targetPosition.setFromMatrixPosition(this.target.matrixWorld); + this.effector._setWorldPosition(this._targetPosition); + } else if (!this.joints[this.joints.length - 1]._isSubBase) { + return; + } + for (var i = 1; i < this.joints.length; i++) { + var joint = this.joints[i]; + if (joint._isSubBase) { + joint._applySubBasePositions(); + } + } + for (var _i = this.joints.length - 1; _i > 0; _i--) { + var _joint = this.joints[_i]; + var prevJoint = this.joints[_i - 1]; + var direction = prevJoint._getWorldDirection(_joint); + var worldPosition = direction.multiplyScalar(_joint.distance).add(_joint._getWorldPosition()); + if (prevJoint === this.base && this.base._isSubBase) { + this.base._subBasePositions.push(worldPosition); + } else { + prevJoint._setWorldPosition(worldPosition); + } + } + } + }, { + key: '_backward', + value: function _backward() { + if (!this.base._isSubBase) { + this.base._setWorldPosition(this.origin); + } + for (var i = 0; i < this.joints.length - 1; i++) { + var joint = this.joints[i]; + var nextJoint = this.joints[i + 1]; + var jointWorldPosition = joint._getWorldPosition(); + var direction = nextJoint._getWorldDirection(joint); + joint._setDirection(direction); + joint._applyConstraints(); + direction.copy(joint._direction); + if (!(this.base === joint && joint._isSubBase)) { + joint._applyWorldPosition(); + } + nextJoint._setWorldPosition(direction.multiplyScalar(nextJoint.distance).add(jointWorldPosition)); + if (i === this.joints.length - 2) { + if (nextJoint !== this.effector) { + nextJoint._setDirection(direction); + } + nextJoint._applyWorldPosition(); + } + } + return this._getDistanceFromTarget(); + } + }]); + return IKChain; +}(); + +var IK = function () { + function IK() { + classCallCheck(this, IK); + this.chains = []; + this._needsRecalculated = true; + this.isIK = true; + this._orderedChains = null; + } + createClass(IK, [{ + key: 'add', + value: function add(chain) { + if (!chain.isIKChain) { + throw new Error('Argument is not an IKChain.'); + } + this.chains.push(chain); + } + }, { + key: 'recalculate', + value: function recalculate() { + this._orderedChains = []; + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + try { + for (var _iterator = this.chains[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var rootChain = _step.value; + var orderedChains = []; + this._orderedChains.push(orderedChains); + var chainsToSave = [rootChain]; + while (chainsToSave.length) { + var chain = chainsToSave.shift(); + orderedChains.push(chain); + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + try { + for (var _iterator2 = chain.chains.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var subChains = _step2.value; + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = undefined; + try { + for (var _iterator3 = subChains[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var subChain = _step3.value; + if (chainsToSave.indexOf(subChain) !== -1) { + throw new Error('Recursive chain structure detected.'); + } + chainsToSave.push(subChain); + } + } catch (err) { + _didIteratorError3 = true; + _iteratorError3 = err; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + } + }, { + key: 'solve', + value: function solve() { + if (!this._orderedChains) { + this.recalculate(); + } + var _iteratorNormalCompletion4 = true; + var _didIteratorError4 = false; + var _iteratorError4 = undefined; + try { + for (var _iterator4 = this._orderedChains[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + var subChains = _step4.value; + var iterations = 1; + while (iterations > 0) { + for (var i = subChains.length - 1; i >= 0; i--) { + subChains[i]._updateJointWorldPositions(); + } + for (var _i = subChains.length - 1; _i >= 0; _i--) { + subChains[_i]._forward(); + } + var withinTolerance = true; + for (var _i2 = 0; _i2 < subChains.length; _i2++) { + var distanceFromTarget = subChains[_i2]._backward(); + if (distanceFromTarget > this.tolerance) { + withinTolerance = false; + } + } + if (withinTolerance) { + break; + } + iterations--; + + } + } + } catch (err) { + _didIteratorError4 = true; + _iteratorError4 = err; + } finally { + try { + if (!_iteratorNormalCompletion4 && _iterator4.return) { + _iterator4.return(); + } + } finally { + if (_didIteratorError4) { + throw _iteratorError4; + } + } + } + } + }, { + key: 'getRootBone', + value: function getRootBone() { + return this.chains[0].base.bone; + } + }]); + return IK; +}(); + +var BoneHelper = function (_Object3D) { + inherits(BoneHelper, _Object3D); + function BoneHelper(height, boneSize, axesSize) { + classCallCheck(this, BoneHelper); + var _this = possibleConstructorReturn(this, (BoneHelper.__proto__ || Object.getPrototypeOf(BoneHelper)).call(this)); + if (height !== 0) { + var geo = new three.ConeBufferGeometry(boneSize, height, 4); + geo.applyMatrix(new three.Matrix4().makeRotationAxis(new three.Vector3(1, 0, 0), Math.PI / 2)); + _this.boneMesh = new three.Mesh(geo, new three.MeshBasicMaterial({ + color: 0xff0000, + wireframe: true, + depthTest: false, + depthWrite: false + })); + } else { + _this.boneMesh = new three.Object3D(); + } + _this.boneMesh.position.z = height / 2; + _this.add(_this.boneMesh); + _this.axesHelper = new three.AxesHelper(axesSize); + _this.add(_this.axesHelper); + return _this; + } + return BoneHelper; +}(three.Object3D); +var IKHelper = function (_Object3D2) { + inherits(IKHelper, _Object3D2); + function IKHelper(ik) { + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + color = _ref.color, + showBones = _ref.showBones, + boneSize = _ref.boneSize, + showAxes = _ref.showAxes, + axesSize = _ref.axesSize, + wireframe = _ref.wireframe; + classCallCheck(this, IKHelper); + var _this2 = possibleConstructorReturn(this, (IKHelper.__proto__ || Object.getPrototypeOf(IKHelper)).call(this)); + boneSize = boneSize || 0.1; + axesSize = axesSize || 0.2; + if (!ik.isIK) { + throw new Error('IKHelper must receive an IK instance.'); + } + _this2.ik = ik; + _this2._meshes = new Map(); + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + try { + for (var _iterator = _this2.ik.chains[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var rootChain = _step.value; + var chainsToMeshify = [rootChain]; + while (chainsToMeshify.length) { + var chain = chainsToMeshify.shift(); + for (var i = 0; i < chain.joints.length; i++) { + var joint = chain.joints[i]; + var nextJoint = chain.joints[i + 1]; + var distance = nextJoint ? nextJoint.distance : 0; + if (chain.base === joint && chain !== rootChain) { + continue; + } + var mesh = new BoneHelper(distance, boneSize, axesSize); + mesh.matrixAutoUpdate = false; + _this2._meshes.set(joint, mesh); + _this2.add(mesh); + } + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + try { + for (var _iterator2 = chain.chains.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var subChains = _step2.value; + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = undefined; + try { + for (var _iterator3 = subChains[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var subChain = _step3.value; + chainsToMeshify.push(subChain); + } + } catch (err) { + _didIteratorError3 = true; + _iteratorError3 = err; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + _this2.showBones = showBones !== undefined ? showBones : true; + _this2.showAxes = showAxes !== undefined ? showAxes : true; + _this2.wireframe = wireframe !== undefined ? wireframe : true; + _this2.color = color || new three.Color(0xff0077); + return _this2; + } + createClass(IKHelper, [{ + key: 'updateMatrixWorld', + value: function updateMatrixWorld(force) { + var _iteratorNormalCompletion4 = true; + var _didIteratorError4 = false; + var _iteratorError4 = undefined; + try { + for (var _iterator4 = this._meshes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + var _ref2 = _step4.value; + var _ref3 = slicedToArray(_ref2, 2); + var joint = _ref3[0]; + var mesh = _ref3[1]; + mesh.matrix.copy(joint.bone.matrixWorld); + } + } catch (err) { + _didIteratorError4 = true; + _iteratorError4 = err; + } finally { + try { + if (!_iteratorNormalCompletion4 && _iterator4.return) { + _iterator4.return(); + } + } finally { + if (_didIteratorError4) { + throw _iteratorError4; + } + } + } + get(IKHelper.prototype.__proto__ || Object.getPrototypeOf(IKHelper.prototype), 'updateMatrixWorld', this).call(this, force); + } + }, { + key: 'showBones', + get: function get$$1() { + return this._showBones; + }, + set: function set$$1(showBones) { + if (showBones === this._showBones) { + return; + } + var _iteratorNormalCompletion5 = true; + var _didIteratorError5 = false; + var _iteratorError5 = undefined; + try { + for (var _iterator5 = this._meshes[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) { + var _ref4 = _step5.value; + var _ref5 = slicedToArray(_ref4, 2); + var mesh = _ref5[1]; + if (showBones) { + mesh.add(mesh.boneMesh); + } else { + mesh.remove(mesh.boneMesh); + } + } + } catch (err) { + _didIteratorError5 = true; + _iteratorError5 = err; + } finally { + try { + if (!_iteratorNormalCompletion5 && _iterator5.return) { + _iterator5.return(); + } + } finally { + if (_didIteratorError5) { + throw _iteratorError5; + } + } + } + this._showBones = showBones; + } + }, { + key: 'showAxes', + get: function get$$1() { + return this._showAxes; + }, + set: function set$$1(showAxes) { + if (showAxes === this._showAxes) { + return; + } + var _iteratorNormalCompletion6 = true; + var _didIteratorError6 = false; + var _iteratorError6 = undefined; + try { + for (var _iterator6 = this._meshes[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) { + var _ref6 = _step6.value; + var _ref7 = slicedToArray(_ref6, 2); + var mesh = _ref7[1]; + if (showAxes) { + mesh.add(mesh.axesHelper); + } else { + mesh.remove(mesh.axesHelper); + } + } + } catch (err) { + _didIteratorError6 = true; + _iteratorError6 = err; + } finally { + try { + if (!_iteratorNormalCompletion6 && _iterator6.return) { + _iterator6.return(); + } + } finally { + if (_didIteratorError6) { + throw _iteratorError6; + } + } + } + this._showAxes = showAxes; + } + }, { + key: 'wireframe', + get: function get$$1() { + return this._wireframe; + }, + set: function set$$1(wireframe) { + if (wireframe === this._wireframe) { + return; + } + var _iteratorNormalCompletion7 = true; + var _didIteratorError7 = false; + var _iteratorError7 = undefined; + try { + for (var _iterator7 = this._meshes[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) { + var _ref8 = _step7.value; + var _ref9 = slicedToArray(_ref8, 2); + var mesh = _ref9[1]; + if (mesh.boneMesh.material) { + mesh.boneMesh.material.wireframe = wireframe; + } + } + } catch (err) { + _didIteratorError7 = true; + _iteratorError7 = err; + } finally { + try { + if (!_iteratorNormalCompletion7 && _iterator7.return) { + _iterator7.return(); + } + } finally { + if (_didIteratorError7) { + throw _iteratorError7; + } + } + } + this._wireframe = wireframe; + } + }, { + key: 'color', + get: function get$$1() { + return this._color; + }, + set: function set$$1(color) { + if (this._color && this._color.equals(color)) { + return; + } + color = color && color.isColor ? color : new three.Color(color); + var _iteratorNormalCompletion8 = true; + var _didIteratorError8 = false; + var _iteratorError8 = undefined; + try { + for (var _iterator8 = this._meshes[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) { + var _ref10 = _step8.value; + var _ref11 = slicedToArray(_ref10, 2); + var mesh = _ref11[1]; + if (mesh.boneMesh.material) { + mesh.boneMesh.material.color = color; + } + } + } catch (err) { + _didIteratorError8 = true; + _iteratorError8 = err; + } finally { + try { + if (!_iteratorNormalCompletion8 && _iterator8.return) { + _iterator8.return(); + } + } finally { + if (_didIteratorError8) { + throw _iteratorError8; + } + } + } + this._color = color; + } + }]); + return IKHelper; +}(three.Object3D); + +if (typeof window !== 'undefined' && _typeof(window.THREE) === 'object') { + window.THREE.IK = IK; + window.THREE.IKChain = IKChain; + window.THREE.IKJoint = IKJoint; + window.THREE.IKBallConstraint = IKBallConstraint; + window.THREE.IKHelper = IKHelper; +} + +exports.IK = IK; +exports.IKChain = IKChain; +exports.IKJoint = IKJoint; +exports.IKBallConstraint = IKBallConstraint; +exports.IKHelper = IKHelper; + +Object.defineProperty(exports, '__esModule', { value: true }); + +}))); From b3068f160c7e2f427f95f74f13583f5b8a5e82fa Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 9 Oct 2019 00:19:46 -0400 Subject: [PATCH 003/562] Include three-ik.js --- app.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/app.html b/app.html index cb11323..b55d9f4 100644 --- a/app.html +++ b/app.html @@ -16,7 +16,8 @@ - + + From f65a87ca527ab06af0e57858025169dd12a0cf2d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 9 Oct 2019 00:19:58 -0400 Subject: [PATCH 004/562] Add model imports to app.html --- app.html | 3 +++ 1 file changed, 3 insertions(+) diff --git a/app.html b/app.html index b55d9f4..ed7a244 100644 --- a/app.html +++ b/app.html @@ -26,6 +26,9 @@ + + @@ -25,9 +27,9 @@ - - + @@ -420,6 +420,7 @@ zForward: true, group, }; + Object.assign(o, resource); avatarMesh.riggedModel = new RiggedModel(model, o); // avatarMesh.riggedModel.rebind(o.group); From ead45181c9f4eff4b9bdaf42aef334093fc97aaa Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Thu, 10 Oct 2019 03:51:23 -0400 Subject: [PATCH 013/562] Dead code cleanup --- app.html | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/app.html b/app.html index 10c7bb6..7b513c9 100644 --- a/app.html +++ b/app.html @@ -518,8 +518,6 @@ if (avatarMesh && avatarMesh.riggedModel) { const {hmd, gamepads} = data; - // this.avatarMesh.position.fromArray(hmd.position).sub(localVector.set(0, 1.5, 0)); - avatarMesh.riggedModel.targets.Head.position.fromArray(hmd.position); avatarMesh.riggedModel.targets.Head.quaternion.fromArray(hmd.quaternion); @@ -528,14 +526,6 @@ avatarMesh.riggedModel.targets.LeftHand.quaternion.fromArray(leftGamepad.quaternion); avatarMesh.riggedModel.targets.RightHand.position.fromArray(rightGamepad.position); avatarMesh.riggedModel.targets.RightHand.quaternion.fromArray(rightGamepad.quaternion); - - /* localQuaternion.fromArray(hmd.quaternion); - localEuler.setFromQuaternion(localQuaternion, localEuler.order); - localEuler.y += Math.PI; - localEuler.x *= -1; - this.avatarMesh.quaternion.setFromEuler(localEuler); - - avatarMesh.riggedModel.setState(hmd, gamepads); */ } } else if (landState && method === 'initState') { const {state} = data; @@ -6172,11 +6162,9 @@ const _updateAvatarMeshes = () => { for (let i = 0; i < avatarMeshes.length; i++) { const avatarMesh = avatarMeshes[i]; - // avatarMesh.riggedModel && avatarMesh.riggedModel.update(); const timeDelta = clock.getDelta() * 1000; const time = clock.elapsedTime * 1000; avatarMesh.riggedModel && avatarMesh.riggedModel.tick(time, timeDelta); - // avatarMesh.riggedModel && avatarMesh.riggedModel.fallback(avatarMesh.riggedModel.targets, time, timeDelta); } }; _updateAvatarMeshes(); From 7b284fbfbb10781fd5f55a975478269770364e98 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Thu, 10 Oct 2019 03:52:01 -0400 Subject: [PATCH 014/562] Add initial vrm model scheme --- proto/remapJointNames.js | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/proto/remapJointNames.js b/proto/remapJointNames.js index 39da92a..1191f2b 100644 --- a/proto/remapJointNames.js +++ b/proto/remapJointNames.js @@ -35,6 +35,40 @@ Object.assign(schemes, { .replace('Chest', 'Spine1'); }, }, + vrm: { + __proto__: schemes, + //Hips,Spine,Chest,Neck,Head,LeftEye,RightEye,ShoulderL,Upper_armL,Lower_armL,HandL,Upper_pointerL,Mid_pointerL,Upper_midL,Mid_midL,Upper_ringL,Mid_ringL,Upper_pinkieL,Lower_pinkieL,Upper_thumbL,Lower_thumbL,ShoulderR,Upper_armR,Lower_armR,HandR,Upper_pointerR,Mid_pointerR,Upper_midR,Mid_midR,Upper_ringR,Mid_ringR,Upper_pinkieR,Lower_pinkieR,Upper_thumbR,Lower_thumbR,Upper_legL,Lower_legL,FootL,ToeL,Upper_tail,Lower_tail,Upper_legR,Lower_legR,FootR,ToeR + re: /^J_Bip_C_Hips$/, + remap: function(from) { + return from + .replace('J_Bip_C_Hips', 'Hips') + .replace('J_Bip_C_Spine', 'Spine') + .replace('J_Bip_C_Chest', 'Spine1') + .replace('J_Bip_C_Neck', 'Neck') + .replace('J_Bip_C_Head', 'Head') + + .replace('J_Adj_L_FaceEye', 'LeftEye') + .replace('J_Adj_R_FaceEye', 'RightEye') + + .replace('J_Bip_L_Shoulder', 'LeftShoulder') + .replace('J_Bip_L_UpperArm', 'LeftArm') + .replace('J_Bip_L_LowerArm', 'LeftForeArm') + .replace('J_Bip_L_Hand', 'LeftHand') + + .replace('J_Bip_R_Shoulder', 'RightShoulder') + .replace('J_Bip_R_UpperArm', 'RightArm') + .replace('J_Bip_R_LowerArm', 'RightForeArm') + .replace('J_Bip_R_Hand', 'RightHand') + + .replace('J_Bip_L_UpperLeg', 'LeftUpLeg') + .replace('J_Bip_L_LowerLeg', 'LeftLeg') + .replace('J_Bip_L_Foot', 'LeftFoot') + + .replace('J_Bip_R_UpperLeg', 'RightUpLeg') + .replace('J_Bip_R_LowerLeg', 'RightLeg') + .replace('J_Bip_R_Foot', 'RightFoot'); + }, + }, side_winder: { __proto__: schemes, re: /^Left_wrist$/, @@ -86,6 +120,7 @@ function remapJointNames(skeleton, remapper) { schemes.mixamo, schemes.side_winder, schemes.knuckles, + schemes.vrm, ].map(function(x) { return typeof x === 'function' ? x : (x && x.match(skeleton)); }).filter(Boolean); From 9a752cd9ad8a7c2234ddac3b37ce6f186cc7a2e6 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Thu, 10 Oct 2019 03:52:46 -0400 Subject: [PATCH 015/562] Add initial anne.glb model --- proto/model.patches.js | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/proto/model.patches.js b/proto/model.patches.js index 6c9a4dd..52dc16d 100644 --- a/proto/model.patches.js +++ b/proto/model.patches.js @@ -147,6 +147,21 @@ var model_patches = { RightHand: [0,180,0], }, }, + anne: { + url: 'anne.glb', + preRotations: { + /* Armature: [0,180,0], */ + // Head: [-90,180,0], + // Spine: [-180,0,0], + // Spine1: [-180,0,0], + // Armature: [-180, 0, 0], + // Hips: [-180,0,0], + /* LeftEye: [90,0,0], + RightEye: [90,0,0], + LeftHand: [0,180,0], + RightHand: [0,180,0], */ + }, + } }; try { self.model_patches = model_patches; } catch(e) {} From 1748c53a71d12035c2f1cad777ee95d0df643bdb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Thu, 10 Oct 2019 03:53:25 -0400 Subject: [PATCH 016/562] Add initial anne model load hack --- app.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app.html b/app.html index 7b513c9..9bf2755 100644 --- a/app.html +++ b/app.html @@ -400,8 +400,8 @@ avatarMesh.riggedModel = null; const loader = new THREE.GLTFLoader(); // const u = 'https://modulesio.github.io/models/miku.glb'; - // const u = 'model4.glb'; const resource = model_patches.model4; + // const resource = model_patches.anne; loader.load(resource.url, object => { if (avatarMesh) { const model = object.scene; From 8469414600ba022ef651f563740a4ac9a1dd840b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Thu, 10 Oct 2019 03:53:58 -0400 Subject: [PATCH 017/562] Use anne model in app.html --- app.html | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app.html b/app.html index 9bf2755..8ea336d 100644 --- a/app.html +++ b/app.html @@ -400,8 +400,8 @@ avatarMesh.riggedModel = null; const loader = new THREE.GLTFLoader(); // const u = 'https://modulesio.github.io/models/miku.glb'; - const resource = model_patches.model4; - // const resource = model_patches.anne; + // const resource = model_patches.model4; + const resource = model_patches.anne; loader.load(resource.url, object => { if (avatarMesh) { const model = object.scene; From 51227e7d54732ad68ce3c407e47134255b1c6c95 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 11:35:39 -0400 Subject: [PATCH 018/562] Add VRArmIK C# source --- vrarmik/ArmTransforms.cs | 81 ++++ vrarmik/ArmTransforms.cs.meta | 13 + vrarmik/AvatarPlatformOffset.cs | 19 + vrarmik/AvatarPlatformOffset.cs.meta | 11 + vrarmik/AvatarVRTrackingReferences.cs | 79 ++++ vrarmik/AvatarVRTrackingReferences.cs.meta | 13 + vrarmik/LocalVrTrackingInput.cs | 21 + vrarmik/LocalVrTrackingInput.cs.meta | 13 + vrarmik/PoseManager.cs | 92 +++++ vrarmik/PoseManager.cs.meta | 13 + vrarmik/ShoulderPoser.cs | 293 ++++++++++++++ vrarmik/ShoulderPoser.cs.meta | 13 + vrarmik/ShoulderTransforms.cs | 51 +++ vrarmik/ShoulderTransforms.cs.meta | 13 + vrarmik/StaticOffsetTransform.cs | 116 ++++++ vrarmik/StaticOffsetTransform.cs.meta | 13 + vrarmik/Utils.meta | 10 + vrarmik/Utils/Editor.meta | 10 + .../Utils/Editor/LabelOverrideInspector.cs | 13 + .../Editor/LabelOverrideInspector.cs.meta | 13 + vrarmik/Utils/Editor/ReadOnlyInspector.cs | 39 ++ .../Utils/Editor/ReadOnlyInspector.cs.meta | 13 + vrarmik/Utils/Extensions.cs | 301 ++++++++++++++ vrarmik/Utils/Extensions.cs.meta | 13 + vrarmik/Utils/InspectorAttributes.cs | 14 + vrarmik/Utils/InspectorAttributes.cs.meta | 13 + vrarmik/Utils/VectorHelpers.cs | 19 + vrarmik/Utils/VectorHelpers.cs.meta | 13 + vrarmik/VRArmIK.cs | 379 ++++++++++++++++++ vrarmik/VRArmIK.cs.meta | 13 + vrarmik/VRTrackingReferences.cs | 11 + vrarmik/VRTrackingReferences.cs.meta | 13 + 32 files changed, 1741 insertions(+) create mode 100644 vrarmik/ArmTransforms.cs create mode 100644 vrarmik/ArmTransforms.cs.meta create mode 100644 vrarmik/AvatarPlatformOffset.cs create mode 100644 vrarmik/AvatarPlatformOffset.cs.meta create mode 100644 vrarmik/AvatarVRTrackingReferences.cs create mode 100644 vrarmik/AvatarVRTrackingReferences.cs.meta create mode 100644 vrarmik/LocalVrTrackingInput.cs create mode 100644 vrarmik/LocalVrTrackingInput.cs.meta create mode 100644 vrarmik/PoseManager.cs create mode 100644 vrarmik/PoseManager.cs.meta create mode 100644 vrarmik/ShoulderPoser.cs create mode 100644 vrarmik/ShoulderPoser.cs.meta create mode 100644 vrarmik/ShoulderTransforms.cs create mode 100644 vrarmik/ShoulderTransforms.cs.meta create mode 100644 vrarmik/StaticOffsetTransform.cs create mode 100644 vrarmik/StaticOffsetTransform.cs.meta create mode 100644 vrarmik/Utils.meta create mode 100644 vrarmik/Utils/Editor.meta create mode 100644 vrarmik/Utils/Editor/LabelOverrideInspector.cs create mode 100644 vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta create mode 100644 vrarmik/Utils/Editor/ReadOnlyInspector.cs create mode 100644 vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta create mode 100644 vrarmik/Utils/Extensions.cs create mode 100644 vrarmik/Utils/Extensions.cs.meta create mode 100644 vrarmik/Utils/InspectorAttributes.cs create mode 100644 vrarmik/Utils/InspectorAttributes.cs.meta create mode 100644 vrarmik/Utils/VectorHelpers.cs create mode 100644 vrarmik/Utils/VectorHelpers.cs.meta create mode 100644 vrarmik/VRArmIK.cs create mode 100644 vrarmik/VRArmIK.cs.meta create mode 100644 vrarmik/VRTrackingReferences.cs create mode 100644 vrarmik/VRTrackingReferences.cs.meta diff --git a/vrarmik/ArmTransforms.cs b/vrarmik/ArmTransforms.cs new file mode 100644 index 0000000..a9ff175 --- /dev/null +++ b/vrarmik/ArmTransforms.cs @@ -0,0 +1,81 @@ +using UnityEngine; + +namespace VRArmIK +{ + public class ArmTransforms : MonoBehaviour + { + public Transform upperArm, lowerArm, wrist1, wrist2, hand; + + public float upperArmLength => distance(upperArm, lowerArm); + public float lowerArmLength => distance(lowerArm, hand); + public float armLength => upperArmLength + lowerArmLength; + + public bool armLengthByScale = false; + public Vector3 scaleAxis = Vector3.one; + public float scaleHandFactor = .7f; + + float distance(Transform a, Transform b) => (a.position - b.position).magnitude; + + void Start() + { + PoseManager.Instance.onCalibrate += updateArmLengths; + updateArmLengths(); + } + + void updateArmLengths() + { + var shoulderWidth = (upperArm.position - lowerArm.position).magnitude; + var _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2f; + setArmLength(_armLength); + } + + public void setUpperArmLength(float length) + { + if (armLengthByScale) + { + float oldLowerArmLength = distance(lowerArm, hand); + + Vector3 newScale = upperArm.localScale - Vector3.Scale(upperArm.localScale, scaleAxis).magnitude * scaleAxis; + float scaleFactor = Vector3.Scale(upperArm.localScale, scaleAxis).magnitude / upperArmLength * length; + newScale += scaleAxis * scaleFactor; + upperArm.localScale = newScale; + + setLowerArmLength(oldLowerArmLength); + } + else + { + Vector3 pos = lowerArm.localPosition; + pos.x = Mathf.Sign(pos.x) * length; + lowerArm.localPosition = pos; + } + } + + public void setLowerArmLength(float length) + { + if (armLengthByScale) + { + } + else + { + Vector3 pos = hand.localPosition; + pos.x = Mathf.Sign(pos.x) * length; + hand.localPosition = pos; + } + } + + public void setArmLength(float length) + { + float upperArmFactor = .48f; + if (armLengthByScale) + { + upperArm.localScale = upperArm.localScale / armLength * length; + hand.localScale = Vector3.one / (1f - (1f - scaleHandFactor) * (1f - upperArm.localScale.x)); + } + else + { + setUpperArmLength(length * upperArmFactor); + setLowerArmLength(length * (1f - upperArmFactor)); + } + } + } +} \ No newline at end of file diff --git a/vrarmik/ArmTransforms.cs.meta b/vrarmik/ArmTransforms.cs.meta new file mode 100644 index 0000000..5233ee2 --- /dev/null +++ b/vrarmik/ArmTransforms.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: ec032af568a757340beb92f8fea7c65a +timeCreated: 1528126260 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/AvatarPlatformOffset.cs b/vrarmik/AvatarPlatformOffset.cs new file mode 100644 index 0000000..cbc916b --- /dev/null +++ b/vrarmik/AvatarPlatformOffset.cs @@ -0,0 +1,19 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using VRArmIK; + +public class AvatarPlatformOffset : MonoBehaviour +{ + public bool correctVrPlatformOffsetOnStart = true; + + void Start() + { + if (correctVrPlatformOffsetOnStart) + { + var p = transform.position; + p.y -= PoseManager.Instance.vrSystemOffsetHeight; + transform.position = p; + } + } +} diff --git a/vrarmik/AvatarPlatformOffset.cs.meta b/vrarmik/AvatarPlatformOffset.cs.meta new file mode 100644 index 0000000..b6f1e27 --- /dev/null +++ b/vrarmik/AvatarPlatformOffset.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ebc3d0b087754e543af552b66b64c187 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/AvatarVRTrackingReferences.cs b/vrarmik/AvatarVRTrackingReferences.cs new file mode 100644 index 0000000..bb3bf38 --- /dev/null +++ b/vrarmik/AvatarVRTrackingReferences.cs @@ -0,0 +1,79 @@ +using UnityEngine; + +namespace VRArmIK +{ + public class AvatarVRTrackingReferences : MonoBehaviour + { + public StaticOffsetTransform head, hmd, leftHand, rightHand; + + void Start() + { + initTransforms(); + } + + [ContextMenu("init transforms")] + public void initTransforms() + { + createTransforms(); + connectTransforms(); + } + + void setStaticOffsetSettings(StaticOffsetTransform s) + { + s.referenceLocalPosition = false; + s.referenceLocalRotation = false; + s.applyLocalPosition = true; + s.applyLocalRotation = true; + s.applyPosition = true; + s.applyRotation = true; + s.applyForwardOffsetAfterRotationOffset = false; + } + + + void createTransform(ref StaticOffsetTransform t, string name) + { + if (t == null) + { + t = new GameObject(name).AddComponent(); + t.transform.parent = transform; + setStaticOffsetSettings(t); + } + } + + void createHandTransform(ref Transform t, string name, Transform parent) + { + if (t == null) + { + t = new GameObject(name).transform; + t.transform.localPosition = Vector3.zero; + t.transform.parent = parent; + } + } + + void createTransforms() + { + createTransform(ref head, nameof(head)); + createTransform(ref leftHand, nameof(leftHand)); + createTransform(ref rightHand, nameof(rightHand)); + createTransform(ref hmd, nameof(hmd)); + } + + void connectTransforms() + { + StaticOffsetTransform sot = this.GetOrAddComponent(); + if (sot.reference == null) + { + sot.reference = transform.parent; + } + + head.reference = head.reference != null ? head.reference : PoseManager.Instance.vrTransforms.head; + hmd.reference = hmd.reference != null ? hmd.reference : PoseManager.Instance.vrTransforms.hmd; + leftHand.reference = leftHand.reference != null + ? leftHand.reference + : PoseManager.Instance.vrTransforms.leftHand; + rightHand.reference = rightHand.reference != null + ? rightHand.reference + : PoseManager.Instance.vrTransforms.rightHand; + } + } +} \ No newline at end of file diff --git a/vrarmik/AvatarVRTrackingReferences.cs.meta b/vrarmik/AvatarVRTrackingReferences.cs.meta new file mode 100644 index 0000000..cfdb77c --- /dev/null +++ b/vrarmik/AvatarVRTrackingReferences.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 4ead1ab284cddee4ba96204f5eb416da +timeCreated: 1528126940 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/LocalVrTrackingInput.cs b/vrarmik/LocalVrTrackingInput.cs new file mode 100644 index 0000000..abaea21 --- /dev/null +++ b/vrarmik/LocalVrTrackingInput.cs @@ -0,0 +1,21 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.VR; + +namespace VRArmIK +{ + public class LocalVrTrackingInput : MonoBehaviour + { + public UnityEngine.XR.XRNode node; + + void Update() + { + if (UnityEngine.XR.InputTracking.GetLocalPosition(node).magnitude < 0.000001f) + return; + + transform.localPosition = UnityEngine.XR.InputTracking.GetLocalPosition(node); + transform.localRotation = UnityEngine.XR.InputTracking.GetLocalRotation(node); + } + } +} \ No newline at end of file diff --git a/vrarmik/LocalVrTrackingInput.cs.meta b/vrarmik/LocalVrTrackingInput.cs.meta new file mode 100644 index 0000000..9d7d5af --- /dev/null +++ b/vrarmik/LocalVrTrackingInput.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 6deb6fe736bb1fa4f920aa26496ebab4 +timeCreated: 1528128704 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/PoseManager.cs b/vrarmik/PoseManager.cs new file mode 100644 index 0000000..62e14d3 --- /dev/null +++ b/vrarmik/PoseManager.cs @@ -0,0 +1,92 @@ +using UnityEngine; +using UnityEngine.XR; + +namespace VRArmIK +{ + [ExecuteInEditMode] + public class PoseManager : MonoBehaviour + { + public static PoseManager Instance = null; + public VRTrackingReferences vrTransforms; + + public delegate void OnCalibrateListener(); + + public event OnCalibrateListener onCalibrate; + + // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. + // In OpenVR, the 0 position is the ground position and the user is then at (0, playerHeightHmd, 0) if he is in the middle of the room, so I need to correct this for shoulder calculation + public float vrSystemOffsetHeight = 0.0f; + + public const float referencePlayerHeightHmd = 1.7f; + public const float referencePlayerWidthWrist = 1.39f; + public float playerHeightHmd = 1.70f; + public float playerWidthWrist = 1.39f; + public float playerWidthShoulders = 0.31f; + public bool loadPlayerSizeOnAwake = false; + + void OnEnable() + { + if (Instance == null) + { + Instance = this; + } + else if (Instance != null) + { + Debug.LogError("Multiple Instances of PoseManager in Scene"); + } + } + + void Awake() + { + if (loadPlayerSizeOnAwake) + { + loadPlayerSize(); + } + var device = XRSettings.loadedDeviceName; + vrSystemOffsetHeight = string.IsNullOrEmpty(device) || device == "OpenVR" ? 0 : playerHeightHmd; + } + + void Start() + { + onCalibrate += OnCalibrate; + } + + [ContextMenu("calibrate")] + void OnCalibrate() + { + playerHeightHmd = Camera.main.transform.position.y; + } + + void loadPlayerWidthShoulders() + { + playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31f); + } + + public void savePlayerWidthShoulders(float width) + { + PlayerPrefs.SetFloat("VRArmIK_PlayerWidthShoulders", width); + } + + [ContextMenu("setArmLength")] + public void calibrateIK() + { + playerWidthWrist = (vrTransforms.leftHand.position - vrTransforms.rightHand.position).magnitude; + playerHeightHmd = vrTransforms.hmd.position.y; + savePlayerSize(playerHeightHmd, playerWidthWrist); + } + + public void savePlayerSize(float heightHmd, float widthWrist) + { + PlayerPrefs.SetFloat("VRArmIK_PlayerHeightHmd", heightHmd); + PlayerPrefs.SetFloat("VRArmIK_PlayerWidthWrist", widthWrist); + loadPlayerSize(); + onCalibrate?.Invoke(); + } + + public void loadPlayerSize() + { + playerHeightHmd = PlayerPrefs.GetFloat("VRArmIK_PlayerHeightHmd", referencePlayerHeightHmd); + playerWidthWrist = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthWrist", referencePlayerWidthWrist); + } + } +} \ No newline at end of file diff --git a/vrarmik/PoseManager.cs.meta b/vrarmik/PoseManager.cs.meta new file mode 100644 index 0000000..8ccf569 --- /dev/null +++ b/vrarmik/PoseManager.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 944b5c1596f68324a998b2ef2c5a363d +timeCreated: 1528126646 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/ShoulderPoser.cs b/vrarmik/ShoulderPoser.cs new file mode 100644 index 0000000..bbde39b --- /dev/null +++ b/vrarmik/ShoulderPoser.cs @@ -0,0 +1,293 @@ +using UnityEngine; + +namespace VRArmIK +{ + public class ShoulderPoser : MonoBehaviour + { + public ShoulderTransforms shoulder; + public VRTrackingReferences vrTrackingReferences; + public AvatarVRTrackingReferences avatarTrackingReferences; + + public float headNeckDistance = 0.03f; + public Vector3 neckShoulderDistance = new Vector3(0f, -.1f, -0.02f); + + public float maxDeltaHeadRotation = 80f; + + [LabelOverride("max forward rotation")] + public float distinctShoulderRotationLimitForward = 33f; + + [LabelOverride("max backward rotation")] + public float distinctShoulderRotationLimitBackward = 0f; + + [LabelOverride("max upward rotation")] public float distinctShoulderRotationLimitUpward = 33f; + public float distinctShoulderRotationMultiplier = 30; + + public float rightRotationStartHeight = 0f; + public float rightRotationHeightFactor = 142f; + public float rightRotationHeadRotationFactor = 0.3f; + public float rightRotationHeadRotationOffset = -20f; + + public Vector3 headNeckDirectionVector = new Vector3(0f, -1f, -.05f); + public float startShoulderDislocationBefore = 0.005f; + + [Header("Features")] public bool ignoreYPos = true; + public bool autoDetectHandsBehindHead = true; + public bool clampRotationToHead = true; + public bool enableDistinctShoulderRotation = true; + public bool enableShoulderDislocation = true; + + + [Header("Debug")] + [DisplayOnly] + [SerializeField] + bool handsBehindHead = false; + + [DisplayOnly] [SerializeField] bool clampingHeadRotation = false; +#pragma warning disable 414 + [DisplayOnly] [SerializeField] bool shoulderDislocated = false; +#pragma warning restore 414 + public float shoulderRightRotation; + + + Vector3 lastAngle = Vector3.zero; + + + Vector3 leftShoulderAnkerStartLocalPosition, rightShoulderAnkerStartLocalPosition; + + void Start() + { + if (vrTrackingReferences == null) + vrTrackingReferences = PoseManager.Instance.vrTransforms; + + leftShoulderAnkerStartLocalPosition = shoulder.transform.InverseTransformPoint(shoulder.leftShoulderAnchor.position); + rightShoulderAnkerStartLocalPosition = + shoulder.transform.InverseTransformPoint(shoulder.rightShoulderAnchor.position); + } + + void onCalibrate() + { + shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.transform.position - shoulder.leftShoulderAnchor.position) + .magnitude); + shoulder.rightArm.setArmLength((avatarTrackingReferences.rightHand.transform.position - shoulder.rightShoulderAnchor.position) + .magnitude); + } + + protected virtual void Update() + { + shoulder.transform.rotation = Quaternion.identity; + positionShoulder(); + rotateShoulderUp(); + rotateShoulderRight(); + + if (enableDistinctShoulderRotation) + { + rotateLeftShoulder(); + rotateRightShoulder(); + } + + if (enableShoulderDislocation) + { + clampShoulderHandDistance(); + } + else + { + shoulder.leftArm.transform.localPosition = Vector3.zero; + shoulder.rightArm.transform.localPosition = Vector3.zero; + } + + Debug.DrawRay(shoulder.transform.position, shoulder.transform.forward); + } + + protected virtual void rotateLeftShoulder() + { + rotateShoulderUp(shoulder.leftShoulder, shoulder.leftArm, avatarTrackingReferences.leftHand.transform, + leftShoulderAnkerStartLocalPosition, 1f); + + } + + protected virtual void rotateRightShoulder() + { + rotateShoulderUp(shoulder.rightShoulder, shoulder.rightArm, avatarTrackingReferences.rightHand.transform, + rightShoulderAnkerStartLocalPosition, -1f); + } + + void rotateShoulderUp(Transform shoulderSide, ArmTransforms arm, Transform targetHand, + Vector3 initialShoulderLocalPos, float angleSign) + { + Vector3 initialShoulderPos = shoulder.transform.TransformPoint(initialShoulderLocalPos); + Vector3 handShoulderOffset = targetHand.position - initialShoulderPos; + float armLength = arm.armLength; + + Vector3 targetAngle = Vector3.zero; + + float forwardDistanceRatio = Vector3.Dot(handShoulderOffset, shoulder.transform.forward) / armLength; + float upwardDistanceRatio = Vector3.Dot(handShoulderOffset, shoulder.transform.up) / armLength; + if (forwardDistanceRatio > 0f) + { + targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5f) * distinctShoulderRotationMultiplier, 0f, + distinctShoulderRotationLimitForward); + } + else + { + targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08f) * distinctShoulderRotationMultiplier * 10f, + -distinctShoulderRotationLimitBackward, 0f); + } + + targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5f) * distinctShoulderRotationMultiplier, + -distinctShoulderRotationLimitUpward, 0f); + + shoulderSide.localEulerAngles = targetAngle * angleSign; + } + + + void positionShoulder() + { + Vector3 headNeckOffset = avatarTrackingReferences.hmd.transform.rotation * headNeckDirectionVector; + Vector3 targetPosition = avatarTrackingReferences.head.transform.position + headNeckOffset * headNeckDistance; + shoulder.transform.localPosition = + shoulder.transform.parent.InverseTransformPoint(targetPosition) + neckShoulderDistance; + } + + protected virtual void rotateShoulderUp() + { + float angle = getCombinedDirectionAngleUp(); + + Vector3 targetRotation = new Vector3(0f, angle, 0f); + + if (autoDetectHandsBehindHead) + { + detectHandsBehindHead(ref targetRotation); + } + + if (clampRotationToHead) + { + clampHeadRotationDeltaUp(ref targetRotation); + } + + shoulder.transform.eulerAngles = targetRotation; + } + + protected virtual void rotateShoulderRight() + { + float heightDiff = vrTrackingReferences.hmd.transform.position.y - PoseManager.Instance.vrSystemOffsetHeight; + float relativeHeightDiff = -heightDiff / PoseManager.Instance.playerHeightHmd; + + float headRightRotation = VectorHelpers.getAngleBetween(shoulder.transform.forward, + avatarTrackingReferences.hmd.transform.forward, + Vector3.up, shoulder.transform.right) + rightRotationHeadRotationOffset; + float heightFactor = Mathf.Clamp(relativeHeightDiff - rightRotationStartHeight, 0f, 1f); + shoulderRightRotation = heightFactor * rightRotationHeightFactor; + shoulderRightRotation += Mathf.Clamp(headRightRotation * rightRotationHeadRotationFactor * heightFactor, 0f, 50f); + + shoulderRightRotation = Mathf.Clamp(shoulderRightRotation, 0f, 50f); + + Quaternion deltaRot = Quaternion.AngleAxis(shoulderRightRotation, shoulder.transform.right); + + + shoulder.transform.rotation = deltaRot * shoulder.transform.rotation; + positionShoulderRelative(); + } + + protected void positionShoulderRelative() + { + Quaternion deltaRot = Quaternion.AngleAxis(shoulderRightRotation, shoulder.transform.right); + Vector3 shoulderHeadDiff = shoulder.transform.position - avatarTrackingReferences.head.transform.position; + shoulder.transform.position = deltaRot * shoulderHeadDiff + avatarTrackingReferences.head.transform.position; + } + + float getCombinedDirectionAngleUp() + { + Transform leftHand = avatarTrackingReferences.leftHand.transform, rightHand = avatarTrackingReferences.rightHand.transform; + + Vector3 distanceLeftHand = leftHand.position - shoulder.transform.position, + distanceRightHand = rightHand.position - shoulder.transform.position; + + if (ignoreYPos) + { + distanceLeftHand.y = 0; + distanceRightHand.y = 0; + } + + Vector3 directionLeftHand = distanceLeftHand.normalized, + directionRightHand = distanceRightHand.normalized; + + Vector3 combinedDirection = directionLeftHand + directionRightHand; + + return Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180f / Mathf.PI; + } + + void detectHandsBehindHead(ref Vector3 targetRotation) + { + float delta = Mathf.Abs(targetRotation.y - lastAngle.y + 360f) % 360f; + if (delta > 150f && delta < 210f && lastAngle.magnitude > 0.000001f && !clampingHeadRotation) + { + handsBehindHead = !handsBehindHead; + } + + lastAngle = targetRotation; + + if (handsBehindHead) + { + targetRotation.y += 180f; + } + } + + void clampHeadRotationDeltaUp(ref Vector3 targetRotation) + { + float headUpRotation = (avatarTrackingReferences.head.transform.eulerAngles.y + 360f) % 360f; + float targetUpRotation = (targetRotation.y + 360f) % 360f; + + float delta = headUpRotation - targetUpRotation; + + if (delta > maxDeltaHeadRotation && delta < 180f || delta < -180f && delta >= -360f + maxDeltaHeadRotation) + { + targetRotation.y = headUpRotation - maxDeltaHeadRotation; + clampingHeadRotation = true; + } + else if (delta < -maxDeltaHeadRotation && delta > -180 || delta > 180f && delta < 360f - maxDeltaHeadRotation) + { + targetRotation.y = headUpRotation + maxDeltaHeadRotation; + clampingHeadRotation = true; + } + else + { + clampingHeadRotation = false; + } + } + + void clampShoulderHandDistance() + { + Vector3 leftHandVector = avatarTrackingReferences.leftHand.transform.position - shoulder.leftShoulderAnchor.position; + Vector3 rightHandVector = avatarTrackingReferences.rightHand.transform.position - shoulder.rightShoulderAnchor.position; + float leftShoulderHandDistance = leftHandVector.magnitude, rightShoulderHandDistance = rightHandVector.magnitude; + shoulderDislocated = false; + + float startBeforeFactor = (1f - startShoulderDislocationBefore); + + if (leftShoulderHandDistance > shoulder.leftArm.armLength * startBeforeFactor) + { + shoulderDislocated = true; + shoulder.leftArm.transform.position = shoulder.leftShoulderAnchor.position + + leftHandVector.normalized * + (leftShoulderHandDistance - shoulder.leftArm.armLength * startBeforeFactor); + } + else + { + shoulder.leftArm.transform.localPosition = Vector3.zero; + } + + if (rightShoulderHandDistance > shoulder.rightArm.armLength * startBeforeFactor) + { + shoulderDislocated = true; + shoulder.rightArm.transform.position = shoulder.rightShoulderAnchor.position + + rightHandVector.normalized * + (rightShoulderHandDistance - + shoulder.rightArm.armLength * startBeforeFactor); + } + else + { + shoulder.rightArm.transform.localPosition = Vector3.zero; + } + } + } +} \ No newline at end of file diff --git a/vrarmik/ShoulderPoser.cs.meta b/vrarmik/ShoulderPoser.cs.meta new file mode 100644 index 0000000..fe93a44 --- /dev/null +++ b/vrarmik/ShoulderPoser.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: e31d3179dbae073468ca3ac97ec5c295 +timeCreated: 1528126260 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/ShoulderTransforms.cs b/vrarmik/ShoulderTransforms.cs new file mode 100644 index 0000000..283147e --- /dev/null +++ b/vrarmik/ShoulderTransforms.cs @@ -0,0 +1,51 @@ +using UnityEngine; + +namespace VRArmIK +{ + public class ShoulderTransforms : MonoBehaviour + { + public Transform leftShoulder, rightShoulder; + public Transform leftShoulderRenderer, rightShoulderRenderer; + public Transform leftShoulderAnchor, rightShoulderAnchor; + public ArmTransforms leftArmDummy, rightArmDummy; + public ArmTransforms leftArm, rightArm; + + void Awake() + { + if (leftArm == null) + { + leftArm = Instantiate(leftArmDummy, leftShoulderAnchor.position, leftShoulderAnchor.rotation, leftShoulderAnchor); + var armIk = leftArm.GetComponentInChildren(); + armIk.shoulder = this; + armIk.shoulderPoser = GetComponent(); + armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; + } + if (rightArm == null) + { + rightArm = Instantiate(rightArmDummy, leftShoulderAnchor.position, rightShoulderAnchor.rotation, rightShoulderAnchor); + var armIk = rightArm.GetComponentInChildren(); + armIk.shoulder = this; + armIk.shoulderPoser = GetComponent(); + armIk.target = armIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; + } + } + + void Start() + { + setShoulderWidth(PoseManager.Instance.playerWidthShoulders); + } + + public void setShoulderWidth(float width) + { + Vector3 localScale = new Vector3(width * .5f, .05f, .05f); + Vector3 localPosition = new Vector3(width * .25f, 0f, 0f); + + leftShoulderRenderer.localScale = localScale; + leftShoulderRenderer.localPosition = -localPosition; + + rightShoulderRenderer.localScale = localScale; + rightShoulderRenderer.localPosition = localPosition; + } + } + +} \ No newline at end of file diff --git a/vrarmik/ShoulderTransforms.cs.meta b/vrarmik/ShoulderTransforms.cs.meta new file mode 100644 index 0000000..fab1c6c --- /dev/null +++ b/vrarmik/ShoulderTransforms.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 952d2a04990ab5d4e95d91263da82740 +timeCreated: 1528126260 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/StaticOffsetTransform.cs b/vrarmik/StaticOffsetTransform.cs new file mode 100644 index 0000000..8d816a9 --- /dev/null +++ b/vrarmik/StaticOffsetTransform.cs @@ -0,0 +1,116 @@ +using UnityEngine; + +namespace VRArmIK +{ + public class StaticOffsetTransform : MonoBehaviour + { + public enum EulerOrder + { + XYZ, + XZY, + YXZ, + YZX, + ZXY, + ZYX + }; + + public Transform reference = null; + public Vector3 offsetPosition; + public Vector3 offsetRotation; + public Vector3 orientationalOffset; + public Vector3 referenceRotationMultiplicator = Vector3.one; + + public EulerOrder axisOrder; + + public bool referenceLocalPosition = false, referenceLocalRotation = false; + public bool applyLocalPosition = false, applyLocalRotation = false; + public bool applyPosition = true, applyRotation = true; + public bool applyForwardOffsetAfterRotationOffset = false; + + + public static Vector3 switchAxis(Vector3 r, EulerOrder order) + { + switch (order) + { + case EulerOrder.XYZ: + return new Vector3(r.x, r.y, r.z); + case EulerOrder.XZY: + return new Vector3(r.x, r.z, r.y); + case EulerOrder.YXZ: + return new Vector3(r.y, r.x, r.z); + case EulerOrder.YZX: + return new Vector3(r.y, r.z, r.x); + case EulerOrder.ZXY: + return new Vector3(r.z, r.x, r.y); + case EulerOrder.ZYX: + return new Vector3(r.z, r.y, r.x); + + default: + return r; + } + } + + void Awake() + { + updatePosition(); + } + + void Update() + { + updatePosition(); + } + + void updatePosition() + { + if (reference == null) + return; + + Vector3 rot = switchAxis(referenceLocalRotation ? reference.localEulerAngles : reference.eulerAngles, axisOrder) + + offsetRotation; + rot.Scale(referenceRotationMultiplicator); + + Vector3 pos = referenceLocalPosition ? reference.localPosition : reference.position; + + + if (applyForwardOffsetAfterRotationOffset) + { + pos += Quaternion.Euler(rot) * Vector3.right * orientationalOffset.x; + pos += Quaternion.Euler(rot) * Vector3.up * orientationalOffset.y; + pos += Quaternion.Euler(rot) * Vector3.forward * orientationalOffset.z; + } + else + { + pos += reference.right * orientationalOffset.x; + pos += reference.up * orientationalOffset.y; + pos += reference.forward * orientationalOffset.z; + } + + pos += offsetPosition; + + if (applyPosition) + { + if (applyLocalPosition) + { + transform.localPosition = pos; + } + else + { + transform.position = pos; + } + } + + + if (applyRotation) + { + if (applyLocalRotation) + { + transform.localEulerAngles = rot; + } + else + { + transform.eulerAngles = rot; + } + } + } + } +} \ No newline at end of file diff --git a/vrarmik/StaticOffsetTransform.cs.meta b/vrarmik/StaticOffsetTransform.cs.meta new file mode 100644 index 0000000..4489a65 --- /dev/null +++ b/vrarmik/StaticOffsetTransform.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: fbf684afebadf9e448a63ab5775ad7c8 +timeCreated: 1528126990 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/Utils.meta b/vrarmik/Utils.meta new file mode 100644 index 0000000..59a4e8c --- /dev/null +++ b/vrarmik/Utils.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 0e4d0a507fe834b4c8e75a936e694622 +folderAsset: yes +timeCreated: 1528126363 +licenseType: Free +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/Utils/Editor.meta b/vrarmik/Utils/Editor.meta new file mode 100644 index 0000000..99d9d7a --- /dev/null +++ b/vrarmik/Utils/Editor.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: ff05c1415d8afee45b3616972c5e311b +folderAsset: yes +timeCreated: 1528126517 +licenseType: Free +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/Utils/Editor/LabelOverrideInspector.cs b/vrarmik/Utils/Editor/LabelOverrideInspector.cs new file mode 100644 index 0000000..a808af9 --- /dev/null +++ b/vrarmik/Utils/Editor/LabelOverrideInspector.cs @@ -0,0 +1,13 @@ +using UnityEngine; +using UnityEditor; + +[CustomPropertyDrawer(typeof(LabelOverride))] +public class ThisPropertyDrawer : PropertyDrawer +{ + public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) + { + var propertyAttribute = attribute as LabelOverride; + label.text = propertyAttribute?.label; + EditorGUI.PropertyField(position, property, label); + } +} \ No newline at end of file diff --git a/vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta b/vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta new file mode 100644 index 0000000..564a570 --- /dev/null +++ b/vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 3a301e6db22cc5747b54c20deee95547 +timeCreated: 1528126534 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/Utils/Editor/ReadOnlyInspector.cs b/vrarmik/Utils/Editor/ReadOnlyInspector.cs new file mode 100644 index 0000000..3443cbb --- /dev/null +++ b/vrarmik/Utils/Editor/ReadOnlyInspector.cs @@ -0,0 +1,39 @@ +using System.ComponentModel; +using UnityEditor; +using UnityEngine; + +[CustomPropertyDrawer(typeof(DisplayOnlyAttribute))] +public class DisplayOnlyInspector : PropertyDrawer +{ + public override void OnGUI(Rect position, SerializedProperty prop, GUIContent label) + { + string valueStr; + + switch (prop.propertyType) + { + case SerializedPropertyType.Integer: + valueStr = prop.intValue.ToString(); + break; + case SerializedPropertyType.Boolean: + valueStr = prop.boolValue.ToString(); + break; + case SerializedPropertyType.Float: + valueStr = prop.floatValue.ToString("0.00000"); + break; + case SerializedPropertyType.String: + valueStr = prop.stringValue; + break; + case SerializedPropertyType.Vector2: + valueStr = prop.vector2Value.ToString(); + break; + case SerializedPropertyType.Vector3: + valueStr = prop.vector3Value.ToString(); + break; + default: + valueStr = "(not supported)"; + break; + } + + EditorGUI.LabelField(position, label.text, valueStr); + } +} \ No newline at end of file diff --git a/vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta b/vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta new file mode 100644 index 0000000..5944573 --- /dev/null +++ b/vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 995d6e718b3990448939a03e8c25bbf2 +timeCreated: 1528126534 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/Utils/Extensions.cs b/vrarmik/Utils/Extensions.cs new file mode 100644 index 0000000..c2df576 --- /dev/null +++ b/vrarmik/Utils/Extensions.cs @@ -0,0 +1,301 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using UnityEngine; +using UnityEngine.UI; +using Random = UnityEngine.Random; + + +namespace VRArmIK +{ + + public static class LinqExtensions + { + public static void ForEach(this IEnumerable source, Action action) + { + foreach (var item in source) + action(item); + } + } + + public static class UtilsExtensions + { + public static string F(this string self, params object[] objects) + { + return string.Format(self, objects); + } + } + + public static class TransformExtensions + { + public static void SetParentForReal(this Transform self, Transform parent) + { + self.SetParent(parent); + self.localScale = Vector3.one; + } + } + + public static class MonoBehaviourExtensions + { + public static T GetOrAddComponent(this Component self) where T : Component + { + T component = self.GetComponent(); + return component != null ? component : self.gameObject.AddComponent(); + } + + public static T GetOrAddComponentInChildren(this MonoBehaviour self) where T : MonoBehaviour + { + T component = self.GetComponentInChildren(); + return component != null ? component : self.gameObject.AddComponent(); + } + } + + + public static class LayerMaskExtensions + { + public static LayerMask Create(params string[] layerNames) + { + return NamesToMask(layerNames); + } + + public static LayerMask Create(params int[] layerNumbers) + { + return LayerNumbersToMask(layerNumbers); + } + + public static LayerMask NamesToMask(params string[] layerNames) + { + LayerMask ret = (LayerMask)0; + foreach (var name in layerNames) + { + ret |= (1 << LayerMask.NameToLayer(name)); + } + + return ret; + } + + public static LayerMask LayerNumbersToMask(params int[] layerNumbers) + { + LayerMask ret = (LayerMask)0; + foreach (var layer in layerNumbers) + { + ret |= (1 << layer); + } + return ret; + } + + public static LayerMask Inverse(this LayerMask original) + { + return ~original; + } + + public static LayerMask AddToMask(this LayerMask original, params string[] layerNames) + { + return original | NamesToMask(layerNames); + } + + public static LayerMask RemoveFromMask(this LayerMask original, params string[] layerNames) + { + return original & ~NamesToMask(layerNames); + } + + public static string[] MaskToNames(this LayerMask original) + { + var output = new List(); + + for (int i = 0; i < 32; ++i) + { + int shifted = 1 << i; + if ((original & shifted) == shifted) + { + string layerName = LayerMask.LayerToName(i); + if (!string.IsNullOrEmpty(layerName)) + { + output.Add(layerName); + } + } + } + return output.ToArray(); + } + + public static string MaskToString(this LayerMask original) + { + return MaskToString(original, ", "); + } + + public static string MaskToString(this LayerMask original, string delimiter) + { + return string.Join(delimiter, MaskToNames(original)); + } + } + + public static class VectorExtensions + { + public static Vector3 toVector3(this Vector2 self) + { + return new Vector3(self.x, self.y); + } + + public static Vector2 xy(this Vector3 self) + { + return new Vector2(self.x, self.y); + } + + public static Vector2 xz(this Vector3 self) + { + return new Vector2(self.x, self.z); + } + + public static Vector2 yz(this Vector3 self) + { + return new Vector2(self.y, self.y); + } + } + + public static class ListExtensions + { + public static T random(this List self) => self[(int)(self.Count * Random.value)]; + public static T next(this List self, int currentIndex, bool loop = false) + { + currentIndex++; + if (!loop && currentIndex >= self.Count) + { + throw new IndexOutOfRangeException(); + } + + currentIndex %= self.Count; + return self[currentIndex]; + } + + public static T next(this List self, T current, bool loop = false) + { + return self.next(self.IndexOf(current), loop); + } + } + + + public static class RandomExtensions + { + public static Vector2 insideUnitCircle(this System.Random self) + { + float radius = (float)self.NextDouble(); + float angle = (float)self.NextDouble() * Mathf.PI * 2; + + return new Vector2(Mathf.Cos(angle) * radius, Mathf.Sin(angle) * radius); + } + + public static float range(this System.Random self, float min, float max) + { + return (float)(self.NextDouble() * (max - min) + min); + } + + public static Vector3 insideUnitCube(this System.Random self) + { + return new Vector3(self.range(-1f, 1f), self.range(-1f, 1f), self.range(-1f, 1f)); + } + } + + public static class EnumExtenstions + { + public class Enum where T : struct, IConvertible + { + public static int Count + { + get + { + if (!typeof(T).IsEnum) + throw new ArgumentException("T must be an enumerated type"); + + return Enum.GetNames(typeof(T)).Length; + } + } + } + + public static T Next(this T src) where T : struct + { + if (!typeof(T).IsEnum) throw new ArgumentException($"Argumnent {typeof(T).FullName} is not an Enum"); + + T[] Arr = (T[])Enum.GetValues(src.GetType()); + int j = Array.IndexOf(Arr, src) + 1; + return Arr.Length == j ? Arr[0] : Arr[j]; + } + + public static bool IsLast(this T src) where T : struct + { + if (!typeof(T).IsEnum) throw new ArgumentException($"Argumnent {typeof(T).FullName} is not an Enum"); + + T[] Arr = (T[])Enum.GetValues(src.GetType()); + int j = Array.IndexOf(Arr, src); + return Arr.Length == j + 1; + } + } + + public static class UIExtensions + { + public static void setNormalButtonColor(this Button self, Color color) + { + + var buttonColors = self.colors; + buttonColors.normalColor = color; + self.colors = buttonColors; + } + + public static IEnumerator fadeIn(this CanvasGroup self, float duration) + { + float timePassed = 0.0f; + + while (timePassed < duration) + { + self.alpha = timePassed / duration; + timePassed += Time.unscaledDeltaTime; + yield return null; + } + + self.alpha = 1f; + } + + public static IEnumerator fadeOut(this CanvasGroup self, float duration) + { + float timePassed = 0.0f; + + while (timePassed < duration) + { + self.alpha = 1f - timePassed / duration; + timePassed += Time.unscaledDeltaTime; + yield return null; + } + + self.alpha = 0f; + } + } + + public static class IENumerableExtensions + { + public static T random(this IEnumerable self) + { + if (self.Count() == 0) + { + throw new IndexOutOfRangeException(); + } + return self.ElementAt(Random.Range(0, self.Count())); + } + } + + public static class FloatExtensions + { + public static float toSignedEulerAngle(this float self) + { + float result = self.toPositiveEulerAngle(); + if (result > 180f) + result = result - 360f; + return result; + } + + public static float toPositiveEulerAngle(this float self) + { + float result = (self % 360f + 360f) % 360f; + return result; + } + } +} \ No newline at end of file diff --git a/vrarmik/Utils/Extensions.cs.meta b/vrarmik/Utils/Extensions.cs.meta new file mode 100644 index 0000000..8db612c --- /dev/null +++ b/vrarmik/Utils/Extensions.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: dd40c275b2b3c5042bee83817b9d5277 +timeCreated: 1528126366 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/Utils/InspectorAttributes.cs b/vrarmik/Utils/InspectorAttributes.cs new file mode 100644 index 0000000..d319b07 --- /dev/null +++ b/vrarmik/Utils/InspectorAttributes.cs @@ -0,0 +1,14 @@ +using UnityEngine; + +public class DisplayOnlyAttribute : PropertyAttribute +{ +} +public class LabelOverride : PropertyAttribute +{ + public string label; + public LabelOverride(string label) + { + this.label = label; + } + +} \ No newline at end of file diff --git a/vrarmik/Utils/InspectorAttributes.cs.meta b/vrarmik/Utils/InspectorAttributes.cs.meta new file mode 100644 index 0000000..3e7f3ba --- /dev/null +++ b/vrarmik/Utils/InspectorAttributes.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: a729eda56804e2043ac3fc58960a13bb +timeCreated: 1528126528 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/Utils/VectorHelpers.cs b/vrarmik/Utils/VectorHelpers.cs new file mode 100644 index 0000000..fb69917 --- /dev/null +++ b/vrarmik/Utils/VectorHelpers.cs @@ -0,0 +1,19 @@ +using UnityEngine; + +public static class VectorHelpers +{ + public static float axisAngle(Vector3 v, Vector3 forward, Vector3 axis) + { + Vector3 right = Vector3.Cross(axis, forward); + forward = Vector3.Cross(right, axis); + return Mathf.Atan2(Vector3.Dot(v, right), Vector3.Dot(v, forward)) * Mathf.Rad2Deg; + } + + public static float getAngleBetween(Vector3 a, Vector3 b, Vector3 forward, Vector3 axis) + { + float angleA = axisAngle(a, forward, axis); + float angleB = axisAngle(b, forward, axis); + + return Mathf.DeltaAngle(angleA, angleB); + } +} diff --git a/vrarmik/Utils/VectorHelpers.cs.meta b/vrarmik/Utils/VectorHelpers.cs.meta new file mode 100644 index 0000000..2c65cb4 --- /dev/null +++ b/vrarmik/Utils/VectorHelpers.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 56770d9500874ac4d8980df3b398f7ee +timeCreated: 1528126637 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/VRArmIK.cs b/vrarmik/VRArmIK.cs new file mode 100644 index 0000000..a8f3b87 --- /dev/null +++ b/vrarmik/VRArmIK.cs @@ -0,0 +1,379 @@ +using UnityEngine; +using UnityEngine.UI; + +namespace VRArmIK +{ + + public class VRArmIK : MonoBehaviour + { + [System.Serializable] + public class ArmIKElbowSettings + { + public bool calcElbowAngle = true; + public bool clampElbowAngle = true; + public bool softClampElbowAngle = true; + public float maxAngle = 175f, minAngle = 13f, softClampRange = 10f; + public float offsetAngle = 135f; + public float yWeight = -60f; + public float zWeightTop = 260, zWeightBottom = -100, zBorderY = -.25f, zDistanceStart = .6f; + public float xWeight = -50f, xDistanceStart = .1f; + } + + [System.Serializable] + public class BeforePositioningSettings + { + public bool correctElbowOutside = true; + public float weight = -0.5f; + public float startBelowZ = .4f; + public float startAboveY = 0.1f; + } + + [System.Serializable] + public class ElbowCorrectionSettings + { + public bool useFixedElbowWhenNearShoulder = true; + public float startBelowDistance = .5f; + public float startBelowY = 0.1f; + public float weight = 2f; + public Vector3 localElbowPos = new Vector3(0.3f, -1f, -2f); + } + + [System.Serializable] + public class HandSettings + { + public bool useWristRotation = true; + public bool rotateElbowWithHandRight = true; + public bool rotateElbowWithHandForward = true; + public float handDeltaPow = 1.5f, handDeltaFactor = -.3f, handDeltaOffset = 45f; + // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] + public float handDeltaForwardPow = 2f, handDeltaForwardFactor = 1f, handDeltaForwardOffset = 0f, handDeltaForwardDeadzone = .3f; + public float rotateElbowWithHandDelay = .08f; + } + + + public ArmTransforms arm; + public ShoulderTransforms shoulder; + public ShoulderPoser shoulderPoser; + public Transform target; + public bool left = true; + + public ArmIKElbowSettings elbowSettings; + public BeforePositioningSettings beforePositioningSettings; + public ElbowCorrectionSettings elbowCorrectionSettings; + public HandSettings handSettings; + + Vector3 nextLowerArmAngle; + + Quaternion upperArmStartRotation, lowerArmStartRotation, wristStartRotation, handStartRotation; + + float interpolatedDeltaElbow; + float interpolatedDeltaElbowForward; + + void Awake() + { + upperArmStartRotation = arm.upperArm.rotation; + lowerArmStartRotation = arm.lowerArm.rotation; + wristStartRotation = Quaternion.identity; + if (arm.wrist1 != null) + wristStartRotation = arm.wrist1.rotation; + handStartRotation = arm.hand.rotation; + } + + void OnEnable() + { + setUpperArmRotation(Quaternion.identity); + setLowerArmRotation(Quaternion.identity); + setHandRotation(Quaternion.identity); + } + + void LateUpdate() + { + updateUpperArmPosition(); + calcElbowInnerAngle(); + rotateShoulder(); + correctElbowRotation(); + if (elbowSettings.calcElbowAngle) + { + positionElbow(); + if (elbowCorrectionSettings.useFixedElbowWhenNearShoulder) + correctElbowAfterPositioning(); + if (handSettings.rotateElbowWithHandRight) + rotateElbowWithHandRight(); + if (handSettings.rotateElbowWithHandForward) + rotateElbowWithHandFoward(); + rotateHand(); + } + } + + public void updateArmAndTurnElbowUp() + { + updateUpperArmPosition(); + calcElbowInnerAngle(); + rotateShoulder(); + correctElbowRotation(); + } + + void updateUpperArmPosition() + { + //arm.upperArm.position = shoulderAnker.transform.position; + } + + void calcElbowInnerAngle() + { + Vector3 eulerAngles = new Vector3(); + float targetShoulderDistance = (target.position - upperArmPos).magnitude; + float innerAngle; + + if (targetShoulderDistance > arm.armLength) + { + innerAngle = 0f; + } + else + { + innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(arm.upperArmLength, 2f) + Mathf.Pow(arm.lowerArmLength, 2f) - + Mathf.Pow(targetShoulderDistance, 2f)) / (2f * arm.upperArmLength * arm.lowerArmLength), -1f, 1f)) * Mathf.Rad2Deg; + if (left) + innerAngle = 180f - innerAngle; + else + innerAngle = 180f + innerAngle; + if (float.IsNaN(innerAngle)) + { + innerAngle = 180f; + } + } + + eulerAngles.y = innerAngle; + nextLowerArmAngle = eulerAngles; + } + + //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp + void rotateShoulder() + { + Vector3 eulerAngles = new Vector3(); + Vector3 targetShoulderDirection = (target.position - upperArmPos).normalized; + float targetShoulderDistance = (target.position - upperArmPos).magnitude; + + eulerAngles.y = (left ? -1f : 1f) * + Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2f) + Mathf.Pow(arm.upperArmLength, 2f) - + Mathf.Pow(arm.lowerArmLength, 2f)) / (2f * targetShoulderDistance * arm.upperArmLength), -1f, 1f)) * Mathf.Rad2Deg; + if (float.IsNaN(eulerAngles.y)) + eulerAngles.y = 0f; + + + Quaternion shoulderRightRotation = Quaternion.FromToRotation(armDirection, targetShoulderDirection); + setUpperArmRotation(shoulderRightRotation); + arm.upperArm.rotation = Quaternion.AngleAxis(eulerAngles.y, lowerArmRotation * Vector3.up) * arm.upperArm.rotation; + setLowerArmLocalRotation(Quaternion.Euler(nextLowerArmAngle)); + } + + float getElbowTargetAngle() + { + Vector3 localHandPosNormalized = shoulderAnker.InverseTransformPoint(handPos) / arm.armLength; + + // angle from Y + var angle = elbowSettings.yWeight * localHandPosNormalized.y + elbowSettings.offsetAngle; + + // angle from Z + /*angle += Mathf.Lerp(elbowSettings.zWeightBottom, elbowSettings.zWeightTop, Mathf.Clamp01((localHandPosNormalized.y + 1f) - elbowSettings.zBorderY)) * + (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f));*/ + if (localHandPosNormalized.y > 0) + angle += elbowSettings.zWeightTop * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f) * Mathf.Max(localHandPosNormalized.y, 0f)); + else + angle += elbowSettings.zWeightBottom * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f) * Mathf.Max(-localHandPosNormalized.y, 0f)); + + + // angle from X + angle += elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (left ? 1.0f : -1.0f) + elbowSettings.xDistanceStart, 0f); + + if (elbowSettings.clampElbowAngle) + { + if (elbowSettings.softClampElbowAngle) + { + if (angle < elbowSettings.minAngle + elbowSettings.softClampRange) + { + float a = elbowSettings.minAngle + elbowSettings.softClampRange - angle; + angle = elbowSettings.minAngle + elbowSettings.softClampRange * (1f - Mathf.Log(1f + a) * 3f); + } + } + else + { + angle = Mathf.Clamp(angle, elbowSettings.minAngle, elbowSettings.maxAngle); + } + } + + if (left) + angle *= -1f; + + return angle; + } + + void correctElbowRotation() + { + var s = beforePositioningSettings; + + Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; + float elbowOutsideFactor = Mathf.Clamp01( + Mathf.Clamp01((s.startBelowZ - localTargetPos.z) / + Mathf.Abs(s.startBelowZ) * .5f) * + Mathf.Clamp01((localTargetPos.y - s.startAboveY) / + Mathf.Abs(s.startAboveY)) * + Mathf.Clamp01(1f - localTargetPos.x * (left ? -1f : 1f)) + ) * s.weight; + + Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; + Vector3 targetDir = shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (armDirection + Vector3.forward * -.2f) * elbowOutsideFactor : Vector3.zero)); + Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000f); + + Vector3 upperArmUp = upperArmRotation * Vector3.up; + + float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); + float elbowAngle = Vector3.Angle(cross, upperArmUp) + (left ? 0f : 180f); + Quaternion rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); + arm.upperArm.rotation = rotation * arm.upperArm.rotation; + } + + /// + /// reduces calculation problems when hand is moving around shoulder XZ coordinates -> forces elbow to be outside of body + /// + void correctElbowAfterPositioning() + { + var s = elbowCorrectionSettings; + Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; + Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; + Vector3 elbowPos = s.localElbowPos; + + if (left) + elbowPos.x *= -1f; + + Vector3 targetDir = shoulder.transform.rotation * elbowPos.normalized; + Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir); + + Vector3 upperArmUp = upperArmRotation * Vector3.up; + + + Vector3 distance = target.position - upperArmPos; + distance = distance.magnitude * shoulder.transform.InverseTransformDirection(distance / distance.magnitude); + + float weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / arm.armLength) / + s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1f) * 3)) * + Mathf.Clamp01((s.startBelowY - localTargetPos.y) / + s.startBelowY); + + float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); + float elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (left ? 0f : 180f); + Quaternion rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1f), shoulderHandDirection); + arm.upperArm.rotation = rotation * arm.upperArm.rotation; + } + + public void rotateElbow(float angle) + { + Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; + + Quaternion rotation = Quaternion.AngleAxis(angle, shoulderHandDirection); + setUpperArmRotation(rotation * upperArmRotation); + } + + //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp + void positionElbow() + { + float targetElbowAngle = getElbowTargetAngle(); + rotateElbow(targetElbowAngle); + } + + + void rotateElbowWithHandRight() + { + var s = handSettings; + Vector3 handUpVec = target.rotation * Vector3.up; + float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, + lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + + // todo reduce influence if hand local forward rotation is high (hand tilted inside) + Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); + handUpVec = handForwardRotation * handUpVec; + + float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, + lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); + + float deltaElbow = (elbowTargetAngle + (left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180f; + + deltaElbow = Mathf.Sign(deltaElbow) * Mathf.Pow(Mathf.Abs(deltaElbow), s.handDeltaPow) * 180f * s.handDeltaFactor; + interpolatedDeltaElbow = + Mathf.LerpAngle(interpolatedDeltaElbow, deltaElbow, Time.deltaTime / s.rotateElbowWithHandDelay); + rotateElbow(interpolatedDeltaElbow); + } + + void rotateElbowWithHandFoward() + { + var s = handSettings; + Vector3 handRightVec = target.rotation * armDirection; + + float elbowTargetAngleForward = VectorHelpers.getAngleBetween(lowerArmRotation * armDirection, handRightVec, + lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + + float deltaElbowForward = (elbowTargetAngleForward + (left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180f; + + if (Mathf.Abs(deltaElbowForward) < s.handDeltaForwardDeadzone) + deltaElbowForward = 0f; + else + { + deltaElbowForward = (deltaElbowForward - Mathf.Sign(deltaElbowForward) * s.handDeltaForwardDeadzone) / (1f - s.handDeltaForwardDeadzone); + } + + deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180f; + interpolatedDeltaElbowForward = Mathf.LerpAngle(interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); + + float signedInterpolated = interpolatedDeltaElbowForward.toSignedEulerAngle(); + rotateElbow(signedInterpolated * s.handDeltaForwardFactor); + } + + public void rotateHand() + { + if (handSettings.useWristRotation) + { + Vector3 handUpVec = target.rotation * Vector3.up; + float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, + lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + + // todo reduce influence if hand local forward rotation is high (hand tilted inside) + Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); + handUpVec = handForwardRotation * handUpVec; + + float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, + lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); + + elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90f, 90f); + if (arm.wrist1 != null) + setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3f, lowerArmRotation * armDirection) * lowerArmRotation); + if (arm.wrist2 != null) + setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8f, lowerArmRotation * armDirection) * lowerArmRotation); + } + setHandRotation(target.rotation); + } + + Vector3 removeShoulderRightRotation(Vector3 direction) => Quaternion.AngleAxis(-shoulderPoser.shoulderRightRotation, shoulder.transform.right) * direction; + + Vector3 armDirection => left ? Vector3.left : Vector3.right; + Vector3 upperArmPos => arm.upperArm.position; + Vector3 lowerArmPos => arm.lowerArm.position; + Vector3 handPos => arm.hand.position; + Transform shoulderAnker => left ? shoulder.leftShoulderAnchor : shoulder.rightShoulderAnchor; + + Quaternion upperArmRotation => arm.upperArm.rotation * Quaternion.Inverse(upperArmStartRotation); + Quaternion lowerArmRotation => arm.lowerArm.rotation * Quaternion.Inverse(lowerArmStartRotation); + Quaternion handRotation => arm.hand.rotation * Quaternion.Inverse(handStartRotation); + + void setUpperArmRotation(Quaternion rotation) => arm.upperArm.rotation = rotation * upperArmStartRotation; + void setLowerArmRotation(Quaternion rotation) => arm.lowerArm.rotation = rotation * lowerArmStartRotation; + void setLowerArmLocalRotation(Quaternion rotation) => arm.lowerArm.rotation = upperArmRotation * rotation * lowerArmStartRotation; + void setWrist1Rotation(Quaternion rotation) => arm.wrist1.rotation = rotation * wristStartRotation; + void setWrist2Rotation(Quaternion rotation) => arm.wrist2.rotation = rotation * wristStartRotation; + void setWristLocalRotation(Quaternion rotation) => arm.wrist1.rotation = arm.lowerArm.rotation * rotation * wristStartRotation; + + void setHandRotation(Quaternion rotation) => + arm.hand.rotation = arm.hand.rotation = rotation * handStartRotation; + } + + + +} \ No newline at end of file diff --git a/vrarmik/VRArmIK.cs.meta b/vrarmik/VRArmIK.cs.meta new file mode 100644 index 0000000..83cc958 --- /dev/null +++ b/vrarmik/VRArmIK.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 2042600d9ae259848ad6a09a5402a741 +timeCreated: 1528126260 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/vrarmik/VRTrackingReferences.cs b/vrarmik/VRTrackingReferences.cs new file mode 100644 index 0000000..c703d31 --- /dev/null +++ b/vrarmik/VRTrackingReferences.cs @@ -0,0 +1,11 @@ +using UnityEngine; + +namespace VRArmIK +{ + + public class VRTrackingReferences : MonoBehaviour + { + public Transform leftController, rightController, hmd; + public Transform leftHand, rightHand, head; + } +} \ No newline at end of file diff --git a/vrarmik/VRTrackingReferences.cs.meta b/vrarmik/VRTrackingReferences.cs.meta new file mode 100644 index 0000000..ff3b893 --- /dev/null +++ b/vrarmik/VRTrackingReferences.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 3ba5e054e87d9864db4d157ceca462f3 +timeCreated: 1528126807 +licenseType: Free +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: From dec545326864540cc0f2492f4b3f8e29dd05c2c3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 12:03:59 -0400 Subject: [PATCH 019/562] Initial vrarmik porting work --- vrarmik/ArmTransforms.cs | 37 +++++----- vrarmik/ShoulderPoser.cs | 108 +++++++++++++---------------- vrarmik/ShoulderTransforms.cs | 26 +++---- vrarmik/VRArmIK.cs | 125 ++++++++++++++++++++-------------- 4 files changed, 147 insertions(+), 149 deletions(-) diff --git a/vrarmik/ArmTransforms.cs b/vrarmik/ArmTransforms.cs index a9ff175..c7dc298 100644 --- a/vrarmik/ArmTransforms.cs +++ b/vrarmik/ArmTransforms.cs @@ -1,35 +1,33 @@ -using UnityEngine; - -namespace VRArmIK -{ - public class ArmTransforms : MonoBehaviour +class ArmTransforms { - public Transform upperArm, lowerArm, wrist1, wrist2, hand; + Transform upperArm, lowerArm, wrist1, wrist2, hand; - public float upperArmLength => distance(upperArm, lowerArm); - public float lowerArmLength => distance(lowerArm, hand); - public float armLength => upperArmLength + lowerArmLength; + float upperArmLength => distance(upperArm, lowerArm); + float lowerArmLength => distance(lowerArm, hand); + float armLength => upperArmLength + lowerArmLength; - public bool armLengthByScale = false; - public Vector3 scaleAxis = Vector3.one; - public float scaleHandFactor = .7f; + bool armLengthByScale = false; + Vector3 scaleAxis = Vector3.one; + float scaleHandFactor = .7f; - float distance(Transform a, Transform b) => (a.position - b.position).magnitude; + distance(Transform a, Transform b) { + return (a.position - b.position).magnitude; + } - void Start() + Start() { PoseManager.Instance.onCalibrate += updateArmLengths; updateArmLengths(); } - void updateArmLengths() + updateArmLengths() { var shoulderWidth = (upperArm.position - lowerArm.position).magnitude; var _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2f; setArmLength(_armLength); } - public void setUpperArmLength(float length) + setUpperArmLength(float length) { if (armLengthByScale) { @@ -50,7 +48,7 @@ public void setUpperArmLength(float length) } } - public void setLowerArmLength(float length) + setLowerArmLength(float length) { if (armLengthByScale) { @@ -63,7 +61,7 @@ public void setLowerArmLength(float length) } } - public void setArmLength(float length) + setArmLength(float length) { float upperArmFactor = .48f; if (armLengthByScale) @@ -77,5 +75,4 @@ public void setArmLength(float length) setLowerArmLength(length * (1f - upperArmFactor)); } } - } -} \ No newline at end of file + } \ No newline at end of file diff --git a/vrarmik/ShoulderPoser.cs b/vrarmik/ShoulderPoser.cs index bbde39b..a68cc0c 100644 --- a/vrarmik/ShoulderPoser.cs +++ b/vrarmik/ShoulderPoser.cs @@ -1,52 +1,41 @@ -using UnityEngine; - -namespace VRArmIK -{ - public class ShoulderPoser : MonoBehaviour +class ShoulderPoser { - public ShoulderTransforms shoulder; - public VRTrackingReferences vrTrackingReferences; - public AvatarVRTrackingReferences avatarTrackingReferences; + ShoulderTransforms shoulder; + VRTrackingReferences vrTrackingReferences; + AvatarVRTrackingReferences avatarTrackingReferences; - public float headNeckDistance = 0.03f; - public Vector3 neckShoulderDistance = new Vector3(0f, -.1f, -0.02f); + float headNeckDistance = 0.03f; + Vector3 neckShoulderDistance = new Vector3(0f, -.1f, -0.02f); - public float maxDeltaHeadRotation = 80f; + float maxDeltaHeadRotation = 80f; - [LabelOverride("max forward rotation")] - public float distinctShoulderRotationLimitForward = 33f; + float distinctShoulderRotationLimitForward = 33f; - [LabelOverride("max backward rotation")] - public float distinctShoulderRotationLimitBackward = 0f; + float distinctShoulderRotationLimitBackward = 0f; - [LabelOverride("max upward rotation")] public float distinctShoulderRotationLimitUpward = 33f; - public float distinctShoulderRotationMultiplier = 30; + float distinctShoulderRotationLimitUpward = 33f; + float distinctShoulderRotationMultiplier = 30; - public float rightRotationStartHeight = 0f; - public float rightRotationHeightFactor = 142f; - public float rightRotationHeadRotationFactor = 0.3f; - public float rightRotationHeadRotationOffset = -20f; + float rightRotationStartHeight = 0f; + float rightRotationHeightFactor = 142f; + float rightRotationHeadRotationFactor = 0.3f; + float rightRotationHeadRotationOffset = -20f; - public Vector3 headNeckDirectionVector = new Vector3(0f, -1f, -.05f); - public float startShoulderDislocationBefore = 0.005f; + Vector3 headNeckDirectionVector = new Vector3(0f, -1f, -.05f); + float startShoulderDislocationBefore = 0.005f; - [Header("Features")] public bool ignoreYPos = true; - public bool autoDetectHandsBehindHead = true; - public bool clampRotationToHead = true; - public bool enableDistinctShoulderRotation = true; - public bool enableShoulderDislocation = true; + bool ignoreYPos = true; + bool autoDetectHandsBehindHead = true; + bool clampRotationToHead = true; + bool enableDistinctShoulderRotation = true; + bool enableShoulderDislocation = true; - [Header("Debug")] - [DisplayOnly] - [SerializeField] bool handsBehindHead = false; - [DisplayOnly] [SerializeField] bool clampingHeadRotation = false; -#pragma warning disable 414 - [DisplayOnly] [SerializeField] bool shoulderDislocated = false; -#pragma warning restore 414 - public float shoulderRightRotation; + bool clampingHeadRotation = false; + bool shoulderDislocated = false; + float shoulderRightRotation; Vector3 lastAngle = Vector3.zero; @@ -54,7 +43,7 @@ public class ShoulderPoser : MonoBehaviour Vector3 leftShoulderAnkerStartLocalPosition, rightShoulderAnkerStartLocalPosition; - void Start() + Start() { if (vrTrackingReferences == null) vrTrackingReferences = PoseManager.Instance.vrTransforms; @@ -64,7 +53,7 @@ void Start() shoulder.transform.InverseTransformPoint(shoulder.rightShoulderAnchor.position); } - void onCalibrate() + onCalibrate() { shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.transform.position - shoulder.leftShoulderAnchor.position) .magnitude); @@ -72,7 +61,7 @@ void onCalibrate() .magnitude); } - protected virtual void Update() + Update() { shoulder.transform.rotation = Quaternion.identity; positionShoulder(); @@ -98,20 +87,20 @@ protected virtual void Update() Debug.DrawRay(shoulder.transform.position, shoulder.transform.forward); } - protected virtual void rotateLeftShoulder() + rotateLeftShoulder() { rotateShoulderUp(shoulder.leftShoulder, shoulder.leftArm, avatarTrackingReferences.leftHand.transform, leftShoulderAnkerStartLocalPosition, 1f); } - protected virtual void rotateRightShoulder() + rotateRightShoulder() { rotateShoulderUp(shoulder.rightShoulder, shoulder.rightArm, avatarTrackingReferences.rightHand.transform, rightShoulderAnkerStartLocalPosition, -1f); } - void rotateShoulderUp(Transform shoulderSide, ArmTransforms arm, Transform targetHand, + rotateShoulderUp(Transform shoulderSide, ArmTransforms arm, Transform targetHand, Vector3 initialShoulderLocalPos, float angleSign) { Vector3 initialShoulderPos = shoulder.transform.TransformPoint(initialShoulderLocalPos); @@ -140,7 +129,7 @@ void rotateShoulderUp(Transform shoulderSide, ArmTransforms arm, Transform targe } - void positionShoulder() + positionShoulder() { Vector3 headNeckOffset = avatarTrackingReferences.hmd.transform.rotation * headNeckDirectionVector; Vector3 targetPosition = avatarTrackingReferences.head.transform.position + headNeckOffset * headNeckDistance; @@ -148,7 +137,7 @@ void positionShoulder() shoulder.transform.parent.InverseTransformPoint(targetPosition) + neckShoulderDistance; } - protected virtual void rotateShoulderUp() + rotateShoulderUp() { float angle = getCombinedDirectionAngleUp(); @@ -167,13 +156,13 @@ protected virtual void rotateShoulderUp() shoulder.transform.eulerAngles = targetRotation; } - protected virtual void rotateShoulderRight() + rotateShoulderRight() { float heightDiff = vrTrackingReferences.hmd.transform.position.y - PoseManager.Instance.vrSystemOffsetHeight; float relativeHeightDiff = -heightDiff / PoseManager.Instance.playerHeightHmd; - float headRightRotation = VectorHelpers.getAngleBetween(shoulder.transform.forward, - avatarTrackingReferences.hmd.transform.forward, + float headRightRotation = VectorHelpers.getAngleBetween(shoulder.transform.forward, + avatarTrackingReferences.hmd.transform.forward, Vector3.up, shoulder.transform.right) + rightRotationHeadRotationOffset; float heightFactor = Mathf.Clamp(relativeHeightDiff - rightRotationStartHeight, 0f, 1f); shoulderRightRotation = heightFactor * rightRotationHeightFactor; @@ -188,14 +177,14 @@ protected virtual void rotateShoulderRight() positionShoulderRelative(); } - protected void positionShoulderRelative() + positionShoulderRelative() { Quaternion deltaRot = Quaternion.AngleAxis(shoulderRightRotation, shoulder.transform.right); Vector3 shoulderHeadDiff = shoulder.transform.position - avatarTrackingReferences.head.transform.position; shoulder.transform.position = deltaRot * shoulderHeadDiff + avatarTrackingReferences.head.transform.position; } - float getCombinedDirectionAngleUp() + getCombinedDirectionAngleUp() { Transform leftHand = avatarTrackingReferences.leftHand.transform, rightHand = avatarTrackingReferences.rightHand.transform; @@ -216,7 +205,7 @@ float getCombinedDirectionAngleUp() return Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180f / Mathf.PI; } - void detectHandsBehindHead(ref Vector3 targetRotation) + detectHandsBehindHead(ref Vector3 targetRotation) { float delta = Mathf.Abs(targetRotation.y - lastAngle.y + 360f) % 360f; if (delta > 150f && delta < 210f && lastAngle.magnitude > 0.000001f && !clampingHeadRotation) @@ -232,8 +221,8 @@ void detectHandsBehindHead(ref Vector3 targetRotation) } } - void clampHeadRotationDeltaUp(ref Vector3 targetRotation) - { + clampHeadRotationDeltaUp(ref Vector3 targetRotation) + { float headUpRotation = (avatarTrackingReferences.head.transform.eulerAngles.y + 360f) % 360f; float targetUpRotation = (targetRotation.y + 360f) % 360f; @@ -255,7 +244,7 @@ void clampHeadRotationDeltaUp(ref Vector3 targetRotation) } } - void clampShoulderHandDistance() + clampShoulderHandDistance() { Vector3 leftHandVector = avatarTrackingReferences.leftHand.transform.position - shoulder.leftShoulderAnchor.position; Vector3 rightHandVector = avatarTrackingReferences.rightHand.transform.position - shoulder.rightShoulderAnchor.position; @@ -267,8 +256,8 @@ void clampShoulderHandDistance() if (leftShoulderHandDistance > shoulder.leftArm.armLength * startBeforeFactor) { shoulderDislocated = true; - shoulder.leftArm.transform.position = shoulder.leftShoulderAnchor.position + - leftHandVector.normalized * + shoulder.leftArm.transform.position = shoulder.leftShoulderAnchor.position + + leftHandVector.normalized * (leftShoulderHandDistance - shoulder.leftArm.armLength * startBeforeFactor); } else @@ -279,9 +268,9 @@ void clampShoulderHandDistance() if (rightShoulderHandDistance > shoulder.rightArm.armLength * startBeforeFactor) { shoulderDislocated = true; - shoulder.rightArm.transform.position = shoulder.rightShoulderAnchor.position + - rightHandVector.normalized * - (rightShoulderHandDistance - + shoulder.rightArm.transform.position = shoulder.rightShoulderAnchor.position + + rightHandVector.normalized * + (rightShoulderHandDistance - shoulder.rightArm.armLength * startBeforeFactor); } else @@ -289,5 +278,4 @@ void clampShoulderHandDistance() shoulder.rightArm.transform.localPosition = Vector3.zero; } } - } -} \ No newline at end of file + } \ No newline at end of file diff --git a/vrarmik/ShoulderTransforms.cs b/vrarmik/ShoulderTransforms.cs index 283147e..65b53f2 100644 --- a/vrarmik/ShoulderTransforms.cs +++ b/vrarmik/ShoulderTransforms.cs @@ -1,16 +1,12 @@ -using UnityEngine; - -namespace VRArmIK -{ - public class ShoulderTransforms : MonoBehaviour +class ShoulderTransforms { - public Transform leftShoulder, rightShoulder; - public Transform leftShoulderRenderer, rightShoulderRenderer; - public Transform leftShoulderAnchor, rightShoulderAnchor; - public ArmTransforms leftArmDummy, rightArmDummy; - public ArmTransforms leftArm, rightArm; + Transform leftShoulder, rightShoulder; + Transform leftShoulderRenderer, rightShoulderRenderer; + Transform leftShoulderAnchor, rightShoulderAnchor; + ArmTransforms leftArmDummy, rightArmDummy; + ArmTransforms leftArm, rightArm; - void Awake() + Awake() { if (leftArm == null) { @@ -30,12 +26,12 @@ void Awake() } } - void Start() + Start() { setShoulderWidth(PoseManager.Instance.playerWidthShoulders); } - public void setShoulderWidth(float width) + setShoulderWidth(float width) { Vector3 localScale = new Vector3(width * .5f, .05f, .05f); Vector3 localPosition = new Vector3(width * .25f, 0f, 0f); @@ -46,6 +42,4 @@ public void setShoulderWidth(float width) rightShoulderRenderer.localScale = localScale; rightShoulderRenderer.localPosition = localPosition; } - } - -} \ No newline at end of file + } \ No newline at end of file diff --git a/vrarmik/VRArmIK.cs b/vrarmik/VRArmIK.cs index a8f3b87..16cd951 100644 --- a/vrarmik/VRArmIK.cs +++ b/vrarmik/VRArmIK.cs @@ -1,13 +1,10 @@ -using UnityEngine; -using UnityEngine.UI; +import ArmTransforms from './ArmTransforms.js'; +import ShoulderTransforms from './ShoulderTransforms.js'; +import ShoulderPoser from './ShoulderPoser.js'; -namespace VRArmIK -{ - - public class VRArmIK : MonoBehaviour + public class VRArmIK { - [System.Serializable] - public class ArmIKElbowSettings + class ArmIKElbowSettings { public bool calcElbowAngle = true; public bool clampElbowAngle = true; @@ -19,8 +16,7 @@ public class ArmIKElbowSettings public float xWeight = -50f, xDistanceStart = .1f; } - [System.Serializable] - public class BeforePositioningSettings + class BeforePositioningSettings { public bool correctElbowOutside = true; public float weight = -0.5f; @@ -28,8 +24,7 @@ public class BeforePositioningSettings public float startAboveY = 0.1f; } - [System.Serializable] - public class ElbowCorrectionSettings + class ElbowCorrectionSettings { public bool useFixedElbowWhenNearShoulder = true; public float startBelowDistance = .5f; @@ -38,8 +33,7 @@ public class ElbowCorrectionSettings public Vector3 localElbowPos = new Vector3(0.3f, -1f, -2f); } - [System.Serializable] - public class HandSettings + class HandSettings { public bool useWristRotation = true; public bool rotateElbowWithHandRight = true; @@ -50,7 +44,6 @@ public class HandSettings public float rotateElbowWithHandDelay = .08f; } - public ArmTransforms arm; public ShoulderTransforms shoulder; public ShoulderPoser shoulderPoser; @@ -69,7 +62,7 @@ public class HandSettings float interpolatedDeltaElbow; float interpolatedDeltaElbowForward; - void Awake() + Awake() { upperArmStartRotation = arm.upperArm.rotation; lowerArmStartRotation = arm.lowerArm.rotation; @@ -79,14 +72,14 @@ void Awake() handStartRotation = arm.hand.rotation; } - void OnEnable() + OnEnable() { setUpperArmRotation(Quaternion.identity); setLowerArmRotation(Quaternion.identity); setHandRotation(Quaternion.identity); } - void LateUpdate() + LateUpdate() { updateUpperArmPosition(); calcElbowInnerAngle(); @@ -105,7 +98,7 @@ void LateUpdate() } } - public void updateArmAndTurnElbowUp() + updateArmAndTurnElbowUp() { updateUpperArmPosition(); calcElbowInnerAngle(); @@ -113,12 +106,12 @@ public void updateArmAndTurnElbowUp() correctElbowRotation(); } - void updateUpperArmPosition() + updateUpperArmPosition() { //arm.upperArm.position = shoulderAnker.transform.position; } - void calcElbowInnerAngle() + calcElbowInnerAngle() { Vector3 eulerAngles = new Vector3(); float targetShoulderDistance = (target.position - upperArmPos).magnitude; @@ -147,7 +140,7 @@ void calcElbowInnerAngle() } //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp - void rotateShoulder() + rotateShoulder() { Vector3 eulerAngles = new Vector3(); Vector3 targetShoulderDirection = (target.position - upperArmPos).normalized; @@ -166,7 +159,7 @@ void rotateShoulder() setLowerArmLocalRotation(Quaternion.Euler(nextLowerArmAngle)); } - float getElbowTargetAngle() + getElbowTargetAngle() { Vector3 localHandPosNormalized = shoulderAnker.InverseTransformPoint(handPos) / arm.armLength; @@ -207,7 +200,7 @@ float getElbowTargetAngle() return angle; } - void correctElbowRotation() + correctElbowRotation() { var s = beforePositioningSettings; @@ -235,7 +228,7 @@ void correctElbowRotation() /// /// reduces calculation problems when hand is moving around shoulder XZ coordinates -> forces elbow to be outside of body /// - void correctElbowAfterPositioning() + correctElbowAfterPositioning() { var s = elbowCorrectionSettings; Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; @@ -265,7 +258,7 @@ void correctElbowAfterPositioning() arm.upperArm.rotation = rotation * arm.upperArm.rotation; } - public void rotateElbow(float angle) + rotateElbow(float angle) { Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; @@ -274,14 +267,14 @@ public void rotateElbow(float angle) } //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp - void positionElbow() + positionElbow() { float targetElbowAngle = getElbowTargetAngle(); rotateElbow(targetElbowAngle); } - void rotateElbowWithHandRight() + rotateElbowWithHandRight() { var s = handSettings; Vector3 handUpVec = target.rotation * Vector3.up; @@ -303,7 +296,7 @@ void rotateElbowWithHandRight() rotateElbow(interpolatedDeltaElbow); } - void rotateElbowWithHandFoward() + rotateElbowWithHandFoward() { var s = handSettings; Vector3 handRightVec = target.rotation * armDirection; @@ -327,7 +320,7 @@ void rotateElbowWithHandFoward() rotateElbow(signedInterpolated * s.handDeltaForwardFactor); } - public void rotateHand() + rotateHand() { if (handSettings.useWristRotation) { @@ -351,29 +344,55 @@ public void rotateHand() setHandRotation(target.rotation); } - Vector3 removeShoulderRightRotation(Vector3 direction) => Quaternion.AngleAxis(-shoulderPoser.shoulderRightRotation, shoulder.transform.right) * direction; - - Vector3 armDirection => left ? Vector3.left : Vector3.right; - Vector3 upperArmPos => arm.upperArm.position; - Vector3 lowerArmPos => arm.lowerArm.position; - Vector3 handPos => arm.hand.position; - Transform shoulderAnker => left ? shoulder.leftShoulderAnchor : shoulder.rightShoulderAnchor; - - Quaternion upperArmRotation => arm.upperArm.rotation * Quaternion.Inverse(upperArmStartRotation); - Quaternion lowerArmRotation => arm.lowerArm.rotation * Quaternion.Inverse(lowerArmStartRotation); - Quaternion handRotation => arm.hand.rotation * Quaternion.Inverse(handStartRotation); - - void setUpperArmRotation(Quaternion rotation) => arm.upperArm.rotation = rotation * upperArmStartRotation; - void setLowerArmRotation(Quaternion rotation) => arm.lowerArm.rotation = rotation * lowerArmStartRotation; - void setLowerArmLocalRotation(Quaternion rotation) => arm.lowerArm.rotation = upperArmRotation * rotation * lowerArmStartRotation; - void setWrist1Rotation(Quaternion rotation) => arm.wrist1.rotation = rotation * wristStartRotation; - void setWrist2Rotation(Quaternion rotation) => arm.wrist2.rotation = rotation * wristStartRotation; - void setWristLocalRotation(Quaternion rotation) => arm.wrist1.rotation = arm.lowerArm.rotation * rotation * wristStartRotation; - - void setHandRotation(Quaternion rotation) => - arm.hand.rotation = arm.hand.rotation = rotation * handStartRotation; - } + removeShoulderRightRotation(Vector3 direction) { + return Quaternion.AngleAxis(-shoulderPoser.shoulderRightRotation, shoulder.transform.right) * direction; + } + get armDirection() { + return left ? Vector3.left : Vector3.right; + } + get upperArmPos() { + return arm.upperArm.position; + } + get lowerArmPos() { + return arm.lowerArm.position; + } + get handPos() { + return arm.hand.position; + } + get shoulderAnker() { + return left ? shoulder.leftShoulderAnchor : shoulder.rightShoulderAnchor; + } + get upperArmRotation() { + return arm.upperArm.rotation * Quaternion.Inverse(upperArmStartRotation); + } + get lowerArmRotation() { + return arm.lowerArm.rotation * Quaternion.Inverse(lowerArmStartRotation); + } + get handRotation() { + return arm.hand.rotation * Quaternion.Inverse(handStartRotation); + } -} \ No newline at end of file + setUpperArmRotation(Quaternion rotation) { + return arm.upperArm.rotation = rotation * upperArmStartRotation; + } + setLowerArmRotation(Quaternion rotation) { + return arm.lowerArm.rotation = rotation * lowerArmStartRotation; + } + setLowerArmLocalRotation(Quaternion rotation) { + return arm.lowerArm.rotation = upperArmRotation * rotation * lowerArmStartRotation; + } + setWrist1Rotation(Quaternion rotation) { + return arm.wrist1.rotation = rotation * wristStartRotation; + } + setWrist2Rotation(Quaternion rotation) { + return arm.wrist2.rotation = rotation * wristStartRotation; + } + setWristLocalRotation(Quaternion rotation) { + return arm.wrist1.rotation = arm.lowerArm.rotation * rotation * wristStartRotation; + } + setHandRotation(Quaternion rotation) { + return arm.hand.rotation = arm.hand.rotation = rotation * handStartRotation; + } + } \ No newline at end of file From 40993518193453be8ff736fb35291cf1e55ea8c9 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 12:04:38 -0400 Subject: [PATCH 020/562] Remove vrarmik meta files --- vrarmik/ArmTransforms.cs.meta | 13 ------------- vrarmik/AvatarPlatformOffset.cs.meta | 11 ----------- vrarmik/AvatarVRTrackingReferences.cs.meta | 13 ------------- vrarmik/LocalVrTrackingInput.cs.meta | 13 ------------- vrarmik/PoseManager.cs.meta | 13 ------------- vrarmik/ShoulderPoser.cs.meta | 13 ------------- vrarmik/ShoulderTransforms.cs.meta | 13 ------------- vrarmik/StaticOffsetTransform.cs.meta | 13 ------------- vrarmik/Utils.meta | 10 ---------- vrarmik/VRArmIK.cs.meta | 13 ------------- vrarmik/VRTrackingReferences.cs.meta | 13 ------------- 11 files changed, 138 deletions(-) delete mode 100644 vrarmik/ArmTransforms.cs.meta delete mode 100644 vrarmik/AvatarPlatformOffset.cs.meta delete mode 100644 vrarmik/AvatarVRTrackingReferences.cs.meta delete mode 100644 vrarmik/LocalVrTrackingInput.cs.meta delete mode 100644 vrarmik/PoseManager.cs.meta delete mode 100644 vrarmik/ShoulderPoser.cs.meta delete mode 100644 vrarmik/ShoulderTransforms.cs.meta delete mode 100644 vrarmik/StaticOffsetTransform.cs.meta delete mode 100644 vrarmik/Utils.meta delete mode 100644 vrarmik/VRArmIK.cs.meta delete mode 100644 vrarmik/VRTrackingReferences.cs.meta diff --git a/vrarmik/ArmTransforms.cs.meta b/vrarmik/ArmTransforms.cs.meta deleted file mode 100644 index 5233ee2..0000000 --- a/vrarmik/ArmTransforms.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: ec032af568a757340beb92f8fea7c65a -timeCreated: 1528126260 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/AvatarPlatformOffset.cs.meta b/vrarmik/AvatarPlatformOffset.cs.meta deleted file mode 100644 index b6f1e27..0000000 --- a/vrarmik/AvatarPlatformOffset.cs.meta +++ /dev/null @@ -1,11 +0,0 @@ -fileFormatVersion: 2 -guid: ebc3d0b087754e543af552b66b64c187 -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/AvatarVRTrackingReferences.cs.meta b/vrarmik/AvatarVRTrackingReferences.cs.meta deleted file mode 100644 index cfdb77c..0000000 --- a/vrarmik/AvatarVRTrackingReferences.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 4ead1ab284cddee4ba96204f5eb416da -timeCreated: 1528126940 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/LocalVrTrackingInput.cs.meta b/vrarmik/LocalVrTrackingInput.cs.meta deleted file mode 100644 index 9d7d5af..0000000 --- a/vrarmik/LocalVrTrackingInput.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 6deb6fe736bb1fa4f920aa26496ebab4 -timeCreated: 1528128704 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/PoseManager.cs.meta b/vrarmik/PoseManager.cs.meta deleted file mode 100644 index 8ccf569..0000000 --- a/vrarmik/PoseManager.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 944b5c1596f68324a998b2ef2c5a363d -timeCreated: 1528126646 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/ShoulderPoser.cs.meta b/vrarmik/ShoulderPoser.cs.meta deleted file mode 100644 index fe93a44..0000000 --- a/vrarmik/ShoulderPoser.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: e31d3179dbae073468ca3ac97ec5c295 -timeCreated: 1528126260 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/ShoulderTransforms.cs.meta b/vrarmik/ShoulderTransforms.cs.meta deleted file mode 100644 index fab1c6c..0000000 --- a/vrarmik/ShoulderTransforms.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 952d2a04990ab5d4e95d91263da82740 -timeCreated: 1528126260 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/StaticOffsetTransform.cs.meta b/vrarmik/StaticOffsetTransform.cs.meta deleted file mode 100644 index 4489a65..0000000 --- a/vrarmik/StaticOffsetTransform.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: fbf684afebadf9e448a63ab5775ad7c8 -timeCreated: 1528126990 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/Utils.meta b/vrarmik/Utils.meta deleted file mode 100644 index 59a4e8c..0000000 --- a/vrarmik/Utils.meta +++ /dev/null @@ -1,10 +0,0 @@ -fileFormatVersion: 2 -guid: 0e4d0a507fe834b4c8e75a936e694622 -folderAsset: yes -timeCreated: 1528126363 -licenseType: Free -DefaultImporter: - externalObjects: {} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/VRArmIK.cs.meta b/vrarmik/VRArmIK.cs.meta deleted file mode 100644 index 83cc958..0000000 --- a/vrarmik/VRArmIK.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 2042600d9ae259848ad6a09a5402a741 -timeCreated: 1528126260 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/VRTrackingReferences.cs.meta b/vrarmik/VRTrackingReferences.cs.meta deleted file mode 100644 index ff3b893..0000000 --- a/vrarmik/VRTrackingReferences.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 3ba5e054e87d9864db4d157ceca462f3 -timeCreated: 1528126807 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: From 6b0fc06fc331c4e0885bddca768c560b5b4c4ffc Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 12:08:32 -0400 Subject: [PATCH 021/562] Rename vrarmik .cs -> .js --- vrarmik/{ArmTransforms.cs => ArmTransforms.js} | 0 vrarmik/{AvatarPlatformOffset.cs => AvatarPlatformOffset.js} | 0 ...vatarVRTrackingReferences.cs => AvatarVRTrackingReferences.js} | 0 vrarmik/{LocalVrTrackingInput.cs => LocalVrTrackingInput.js} | 0 vrarmik/{PoseManager.cs => PoseManager.js} | 0 vrarmik/{ShoulderPoser.cs => ShoulderPoser.js} | 0 vrarmik/{ShoulderTransforms.cs => ShoulderTransforms.js} | 0 vrarmik/{StaticOffsetTransform.cs => StaticOffsetTransform.js} | 0 .../{LabelOverrideInspector.cs => LabelOverrideInspector.js} | 0 .../Utils/Editor/{ReadOnlyInspector.cs => ReadOnlyInspector.js} | 0 vrarmik/Utils/{Extensions.cs => Extensions.js} | 0 vrarmik/Utils/{InspectorAttributes.cs => InspectorAttributes.js} | 0 vrarmik/Utils/{VectorHelpers.cs => VectorHelpers.js} | 0 vrarmik/{VRArmIK.cs => VRArmIK.js} | 0 vrarmik/{VRTrackingReferences.cs => VRTrackingReferences.js} | 0 15 files changed, 0 insertions(+), 0 deletions(-) rename vrarmik/{ArmTransforms.cs => ArmTransforms.js} (100%) rename vrarmik/{AvatarPlatformOffset.cs => AvatarPlatformOffset.js} (100%) rename vrarmik/{AvatarVRTrackingReferences.cs => AvatarVRTrackingReferences.js} (100%) rename vrarmik/{LocalVrTrackingInput.cs => LocalVrTrackingInput.js} (100%) rename vrarmik/{PoseManager.cs => PoseManager.js} (100%) rename vrarmik/{ShoulderPoser.cs => ShoulderPoser.js} (100%) rename vrarmik/{ShoulderTransforms.cs => ShoulderTransforms.js} (100%) rename vrarmik/{StaticOffsetTransform.cs => StaticOffsetTransform.js} (100%) rename vrarmik/Utils/Editor/{LabelOverrideInspector.cs => LabelOverrideInspector.js} (100%) rename vrarmik/Utils/Editor/{ReadOnlyInspector.cs => ReadOnlyInspector.js} (100%) rename vrarmik/Utils/{Extensions.cs => Extensions.js} (100%) rename vrarmik/Utils/{InspectorAttributes.cs => InspectorAttributes.js} (100%) rename vrarmik/Utils/{VectorHelpers.cs => VectorHelpers.js} (100%) rename vrarmik/{VRArmIK.cs => VRArmIK.js} (100%) rename vrarmik/{VRTrackingReferences.cs => VRTrackingReferences.js} (100%) diff --git a/vrarmik/ArmTransforms.cs b/vrarmik/ArmTransforms.js similarity index 100% rename from vrarmik/ArmTransforms.cs rename to vrarmik/ArmTransforms.js diff --git a/vrarmik/AvatarPlatformOffset.cs b/vrarmik/AvatarPlatformOffset.js similarity index 100% rename from vrarmik/AvatarPlatformOffset.cs rename to vrarmik/AvatarPlatformOffset.js diff --git a/vrarmik/AvatarVRTrackingReferences.cs b/vrarmik/AvatarVRTrackingReferences.js similarity index 100% rename from vrarmik/AvatarVRTrackingReferences.cs rename to vrarmik/AvatarVRTrackingReferences.js diff --git a/vrarmik/LocalVrTrackingInput.cs b/vrarmik/LocalVrTrackingInput.js similarity index 100% rename from vrarmik/LocalVrTrackingInput.cs rename to vrarmik/LocalVrTrackingInput.js diff --git a/vrarmik/PoseManager.cs b/vrarmik/PoseManager.js similarity index 100% rename from vrarmik/PoseManager.cs rename to vrarmik/PoseManager.js diff --git a/vrarmik/ShoulderPoser.cs b/vrarmik/ShoulderPoser.js similarity index 100% rename from vrarmik/ShoulderPoser.cs rename to vrarmik/ShoulderPoser.js diff --git a/vrarmik/ShoulderTransforms.cs b/vrarmik/ShoulderTransforms.js similarity index 100% rename from vrarmik/ShoulderTransforms.cs rename to vrarmik/ShoulderTransforms.js diff --git a/vrarmik/StaticOffsetTransform.cs b/vrarmik/StaticOffsetTransform.js similarity index 100% rename from vrarmik/StaticOffsetTransform.cs rename to vrarmik/StaticOffsetTransform.js diff --git a/vrarmik/Utils/Editor/LabelOverrideInspector.cs b/vrarmik/Utils/Editor/LabelOverrideInspector.js similarity index 100% rename from vrarmik/Utils/Editor/LabelOverrideInspector.cs rename to vrarmik/Utils/Editor/LabelOverrideInspector.js diff --git a/vrarmik/Utils/Editor/ReadOnlyInspector.cs b/vrarmik/Utils/Editor/ReadOnlyInspector.js similarity index 100% rename from vrarmik/Utils/Editor/ReadOnlyInspector.cs rename to vrarmik/Utils/Editor/ReadOnlyInspector.js diff --git a/vrarmik/Utils/Extensions.cs b/vrarmik/Utils/Extensions.js similarity index 100% rename from vrarmik/Utils/Extensions.cs rename to vrarmik/Utils/Extensions.js diff --git a/vrarmik/Utils/InspectorAttributes.cs b/vrarmik/Utils/InspectorAttributes.js similarity index 100% rename from vrarmik/Utils/InspectorAttributes.cs rename to vrarmik/Utils/InspectorAttributes.js diff --git a/vrarmik/Utils/VectorHelpers.cs b/vrarmik/Utils/VectorHelpers.js similarity index 100% rename from vrarmik/Utils/VectorHelpers.cs rename to vrarmik/Utils/VectorHelpers.js diff --git a/vrarmik/VRArmIK.cs b/vrarmik/VRArmIK.js similarity index 100% rename from vrarmik/VRArmIK.cs rename to vrarmik/VRArmIK.js diff --git a/vrarmik/VRTrackingReferences.cs b/vrarmik/VRTrackingReferences.js similarity index 100% rename from vrarmik/VRTrackingReferences.cs rename to vrarmik/VRTrackingReferences.js From 4bc9052463302d4d721d64309c1bb03a72f68662 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 12:10:37 -0400 Subject: [PATCH 022/562] Clean up VRArmIK classes --- vrarmik/VRArmIK.js | 86 ++++++++++++++++++++++++---------------------- 1 file changed, 44 insertions(+), 42 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 16cd951..cc1066a 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -2,48 +2,48 @@ import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; - public class VRArmIK +class ArmIKElbowSettings +{ + public bool calcElbowAngle = true; + public bool clampElbowAngle = true; + public bool softClampElbowAngle = true; + public float maxAngle = 175f, minAngle = 13f, softClampRange = 10f; + public float offsetAngle = 135f; + public float yWeight = -60f; + public float zWeightTop = 260, zWeightBottom = -100, zBorderY = -.25f, zDistanceStart = .6f; + public float xWeight = -50f, xDistanceStart = .1f; +} + +class BeforePositioningSettings +{ + public bool correctElbowOutside = true; + public float weight = -0.5f; + public float startBelowZ = .4f; + public float startAboveY = 0.1f; +} + +class ElbowCorrectionSettings +{ + public bool useFixedElbowWhenNearShoulder = true; + public float startBelowDistance = .5f; + public float startBelowY = 0.1f; + public float weight = 2f; + public Vector3 localElbowPos = new Vector3(0.3f, -1f, -2f); +} + +class HandSettings +{ + public bool useWristRotation = true; + public bool rotateElbowWithHandRight = true; + public bool rotateElbowWithHandForward = true; + public float handDeltaPow = 1.5f, handDeltaFactor = -.3f, handDeltaOffset = 45f; + // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] + public float handDeltaForwardPow = 2f, handDeltaForwardFactor = 1f, handDeltaForwardOffset = 0f, handDeltaForwardDeadzone = .3f; + public float rotateElbowWithHandDelay = .08f; +} + + class VRArmIK { - class ArmIKElbowSettings - { - public bool calcElbowAngle = true; - public bool clampElbowAngle = true; - public bool softClampElbowAngle = true; - public float maxAngle = 175f, minAngle = 13f, softClampRange = 10f; - public float offsetAngle = 135f; - public float yWeight = -60f; - public float zWeightTop = 260, zWeightBottom = -100, zBorderY = -.25f, zDistanceStart = .6f; - public float xWeight = -50f, xDistanceStart = .1f; - } - - class BeforePositioningSettings - { - public bool correctElbowOutside = true; - public float weight = -0.5f; - public float startBelowZ = .4f; - public float startAboveY = 0.1f; - } - - class ElbowCorrectionSettings - { - public bool useFixedElbowWhenNearShoulder = true; - public float startBelowDistance = .5f; - public float startBelowY = 0.1f; - public float weight = 2f; - public Vector3 localElbowPos = new Vector3(0.3f, -1f, -2f); - } - - class HandSettings - { - public bool useWristRotation = true; - public bool rotateElbowWithHandRight = true; - public bool rotateElbowWithHandForward = true; - public float handDeltaPow = 1.5f, handDeltaFactor = -.3f, handDeltaOffset = 45f; - // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] - public float handDeltaForwardPow = 2f, handDeltaForwardFactor = 1f, handDeltaForwardOffset = 0f, handDeltaForwardDeadzone = .3f; - public float rotateElbowWithHandDelay = .08f; - } - public ArmTransforms arm; public ShoulderTransforms shoulder; public ShoulderPoser shoulderPoser; @@ -395,4 +395,6 @@ import ShoulderPoser from './ShoulderPoser.js'; setHandRotation(Quaternion rotation) { return arm.hand.rotation = arm.hand.rotation = rotation * handStartRotation; } - } \ No newline at end of file + } + +export default VRArmIK; \ No newline at end of file From c64c0ead5af5dd575091634a01ace79b9a260ab6 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 12:12:59 -0400 Subject: [PATCH 023/562] Debugging class exports --- vrarmik/ArmTransforms.js | 4 +++- vrarmik/ShoulderPoser.js | 4 +++- vrarmik/ShoulderTransforms.js | 4 +++- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index c7dc298..2747be0 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -75,4 +75,6 @@ setLowerArmLength(length * (1f - upperArmFactor)); } } - } \ No newline at end of file + } + +export default ArmTransforms; \ No newline at end of file diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index a68cc0c..bc6cf61 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -278,4 +278,6 @@ shoulder.rightArm.transform.localPosition = Vector3.zero; } } - } \ No newline at end of file + } + +export default ShoulderPoser; \ No newline at end of file diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 65b53f2..e1cfc28 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -42,4 +42,6 @@ rightShoulderRenderer.localScale = localScale; rightShoulderRenderer.localPosition = localPosition; } - } \ No newline at end of file + } + +export default ShoulderTransforms; \ No newline at end of file From df54b25584474dfa69cc7fd545f9a265f3652b66 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 12:29:57 -0400 Subject: [PATCH 024/562] JSify VRArmIK.js --- vrarmik/VRArmIK.js | 172 ++++++++++++++++++++++++++------------------- 1 file changed, 98 insertions(+), 74 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index cc1066a..dafb873 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -4,63 +4,87 @@ import ShoulderPoser from './ShoulderPoser.js'; class ArmIKElbowSettings { - public bool calcElbowAngle = true; - public bool clampElbowAngle = true; - public bool softClampElbowAngle = true; - public float maxAngle = 175f, minAngle = 13f, softClampRange = 10f; - public float offsetAngle = 135f; - public float yWeight = -60f; - public float zWeightTop = 260, zWeightBottom = -100, zBorderY = -.25f, zDistanceStart = .6f; - public float xWeight = -50f, xDistanceStart = .1f; + constructor() { + this.calcElbowAngle = true; + this.clampElbowAngle = true; + this.softClampElbowAngle = true; + this.maxAngle = 175; + this.minAngle = 13; + this.softClampRange = 10; + this.offsetAngle = 135; + this.yWeight = -60; + this.zWeightTop = 260; + this.zWeightBottom = -100; + this.zBorderY = -.25; + this.zDistanceStart = .6; + this.xWeight = -50; + this.xDistanceStart = .1; + } } class BeforePositioningSettings { - public bool correctElbowOutside = true; - public float weight = -0.5f; - public float startBelowZ = .4f; - public float startAboveY = 0.1f; + constructor() { + this.correctElbowOutside = true; + this.weight = -0.5; + this.startBelowZ = .4; + this.startAboveY = 0.1; + } } class ElbowCorrectionSettings { - public bool useFixedElbowWhenNearShoulder = true; - public float startBelowDistance = .5f; - public float startBelowY = 0.1f; - public float weight = 2f; - public Vector3 localElbowPos = new Vector3(0.3f, -1f, -2f); + constructor() { + this.useFixedElbowWhenNearShoulder = true; + this.startBelowDistance = .5; + this.startBelowY = 0.1; + this.weight = 2; + this.localElbowPos = new Vector3(0.3, -1, -2); + } } class HandSettings { - public bool useWristRotation = true; - public bool rotateElbowWithHandRight = true; - public bool rotateElbowWithHandForward = true; - public float handDeltaPow = 1.5f, handDeltaFactor = -.3f, handDeltaOffset = 45f; - // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] - public float handDeltaForwardPow = 2f, handDeltaForwardFactor = 1f, handDeltaForwardOffset = 0f, handDeltaForwardDeadzone = .3f; - public float rotateElbowWithHandDelay = .08f; + constructor() { + this.useWristRotation = true; + this.rotateElbowWithHandRight = true; + this.rotateElbowWithHandForward = true; + this.handDeltaPow = 1.5; + this.handDeltaFactor = -.3; + this.handDeltaOffset = 45; + // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] + this.handDeltaForwardPow = 2; + this.handDeltaForwardFactor = 1; + this.handDeltaForwardOffset = 0; + this.handDeltaForwardDeadzone = .3; + this.rotateElbowWithHandDelay = .08; + } } class VRArmIK { - public ArmTransforms arm; - public ShoulderTransforms shoulder; - public ShoulderPoser shoulderPoser; - public Transform target; - public bool left = true; - - public ArmIKElbowSettings elbowSettings; - public BeforePositioningSettings beforePositioningSettings; - public ElbowCorrectionSettings elbowCorrectionSettings; - public HandSettings handSettings; - - Vector3 nextLowerArmAngle; - - Quaternion upperArmStartRotation, lowerArmStartRotation, wristStartRotation, handStartRotation; - - float interpolatedDeltaElbow; - float interpolatedDeltaElbowForward; + constructor() { + this.arm = new ArmTransforms(); // XXX these need to be this'd below + this.shoulder = ShoulderTransforms(); + this.shoulderPoser = new ShoulderPoser(); + this.target = new Transform(); + this.left = true; + + this.elbowSettings = new ArmIKElbowSettings(); + this.beforePositioningSettings = new BeforePositioningSettings(); + this.elbowCorrectionSettings = ElbowCorrectionSettings(); + this.handSettings = new HandSettings(); + + this.nextLowerArmAngle = new Vector3(); + + this.upperArmStartRotation = new Quaternion(); + this.lowerArmStartRotation = new Quaternion(); + this.wristStartRotation = new Quaternion(); + this.handStartRotation = new Quaternion(); + + this.interpolatedDeltaElbow = 0; + this.interpolatedDeltaElbowForward = 0; + } Awake() { @@ -119,19 +143,19 @@ class HandSettings if (targetShoulderDistance > arm.armLength) { - innerAngle = 0f; + innerAngle = 0; } else { - innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(arm.upperArmLength, 2f) + Mathf.Pow(arm.lowerArmLength, 2f) - - Mathf.Pow(targetShoulderDistance, 2f)) / (2f * arm.upperArmLength * arm.lowerArmLength), -1f, 1f)) * Mathf.Rad2Deg; + innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(arm.upperArmLength, 2) + Mathf.Pow(arm.lowerArmLength, 2) - + Mathf.Pow(targetShoulderDistance, 2)) / (2 * arm.upperArmLength * arm.lowerArmLength), -1, 1)) * Mathf.Rad2Deg; if (left) - innerAngle = 180f - innerAngle; + innerAngle = 180 - innerAngle; else - innerAngle = 180f + innerAngle; + innerAngle = 180 + innerAngle; if (float.IsNaN(innerAngle)) { - innerAngle = 180f; + innerAngle = 180; } } @@ -146,11 +170,11 @@ class HandSettings Vector3 targetShoulderDirection = (target.position - upperArmPos).normalized; float targetShoulderDistance = (target.position - upperArmPos).magnitude; - eulerAngles.y = (left ? -1f : 1f) * - Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2f) + Mathf.Pow(arm.upperArmLength, 2f) - - Mathf.Pow(arm.lowerArmLength, 2f)) / (2f * targetShoulderDistance * arm.upperArmLength), -1f, 1f)) * Mathf.Rad2Deg; + eulerAngles.y = (left ? -1 : 1) * + Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(arm.upperArmLength, 2) - + Mathf.Pow(arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; if (float.IsNaN(eulerAngles.y)) - eulerAngles.y = 0f; + eulerAngles.y = 0; Quaternion shoulderRightRotation = Quaternion.FromToRotation(armDirection, targetShoulderDirection); @@ -170,13 +194,13 @@ class HandSettings /*angle += Mathf.Lerp(elbowSettings.zWeightBottom, elbowSettings.zWeightTop, Mathf.Clamp01((localHandPosNormalized.y + 1f) - elbowSettings.zBorderY)) * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f));*/ if (localHandPosNormalized.y > 0) - angle += elbowSettings.zWeightTop * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f) * Mathf.Max(localHandPosNormalized.y, 0f)); + angle += elbowSettings.zWeightTop * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(localHandPosNormalized.y, 0)); else - angle += elbowSettings.zWeightBottom * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f) * Mathf.Max(-localHandPosNormalized.y, 0f)); + angle += elbowSettings.zWeightBottom * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(-localHandPosNormalized.y, 0)); // angle from X - angle += elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (left ? 1.0f : -1.0f) + elbowSettings.xDistanceStart, 0f); + angle += elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (left ? 1.0 : -1.0) + elbowSettings.xDistanceStart, 0); if (elbowSettings.clampElbowAngle) { @@ -185,7 +209,7 @@ class HandSettings if (angle < elbowSettings.minAngle + elbowSettings.softClampRange) { float a = elbowSettings.minAngle + elbowSettings.softClampRange - angle; - angle = elbowSettings.minAngle + elbowSettings.softClampRange * (1f - Mathf.Log(1f + a) * 3f); + angle = elbowSettings.minAngle + elbowSettings.softClampRange * (1 - Mathf.Log(1 + a) * 3); } } else @@ -195,7 +219,7 @@ class HandSettings } if (left) - angle *= -1f; + angle *= -1; return angle; } @@ -207,20 +231,20 @@ class HandSettings Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; float elbowOutsideFactor = Mathf.Clamp01( Mathf.Clamp01((s.startBelowZ - localTargetPos.z) / - Mathf.Abs(s.startBelowZ) * .5f) * + Mathf.Abs(s.startBelowZ) * .5) * Mathf.Clamp01((localTargetPos.y - s.startAboveY) / Mathf.Abs(s.startAboveY)) * - Mathf.Clamp01(1f - localTargetPos.x * (left ? -1f : 1f)) + Mathf.Clamp01(1 - localTargetPos.x * (left ? -1 : 1)) ) * s.weight; Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; - Vector3 targetDir = shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (armDirection + Vector3.forward * -.2f) * elbowOutsideFactor : Vector3.zero)); - Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000f); + Vector3 targetDir = shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (armDirection + Vector3.forward * -.2) * elbowOutsideFactor : Vector3.zero)); + Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000); Vector3 upperArmUp = upperArmRotation * Vector3.up; float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - float elbowAngle = Vector3.Angle(cross, upperArmUp) + (left ? 0f : 180f); + float elbowAngle = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); Quaternion rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); arm.upperArm.rotation = rotation * arm.upperArm.rotation; } @@ -236,7 +260,7 @@ class HandSettings Vector3 elbowPos = s.localElbowPos; if (left) - elbowPos.x *= -1f; + elbowPos.x *= -1; Vector3 targetDir = shoulder.transform.rotation * elbowPos.normalized; Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir); @@ -248,13 +272,13 @@ class HandSettings distance = distance.magnitude * shoulder.transform.InverseTransformDirection(distance / distance.magnitude); float weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / arm.armLength) / - s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1f) * 3)) * + s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1) * 3)) * Mathf.Clamp01((s.startBelowY - localTargetPos.y) / s.startBelowY); float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - float elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (left ? 0f : 180f); - Quaternion rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1f), shoulderHandDirection); + float elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); + Quaternion rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); arm.upperArm.rotation = rotation * arm.upperArm.rotation; } @@ -288,9 +312,9 @@ class HandSettings float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); - float deltaElbow = (elbowTargetAngle + (left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180f; + float deltaElbow = (elbowTargetAngle + (left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180; - deltaElbow = Mathf.Sign(deltaElbow) * Mathf.Pow(Mathf.Abs(deltaElbow), s.handDeltaPow) * 180f * s.handDeltaFactor; + deltaElbow = Mathf.Sign(deltaElbow) * Mathf.Pow(Mathf.Abs(deltaElbow), s.handDeltaPow) * 180 * s.handDeltaFactor; interpolatedDeltaElbow = Mathf.LerpAngle(interpolatedDeltaElbow, deltaElbow, Time.deltaTime / s.rotateElbowWithHandDelay); rotateElbow(interpolatedDeltaElbow); @@ -304,16 +328,16 @@ class HandSettings float elbowTargetAngleForward = VectorHelpers.getAngleBetween(lowerArmRotation * armDirection, handRightVec, lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); - float deltaElbowForward = (elbowTargetAngleForward + (left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180f; + float deltaElbowForward = (elbowTargetAngleForward + (left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180; if (Mathf.Abs(deltaElbowForward) < s.handDeltaForwardDeadzone) - deltaElbowForward = 0f; + deltaElbowForward = 0; else { - deltaElbowForward = (deltaElbowForward - Mathf.Sign(deltaElbowForward) * s.handDeltaForwardDeadzone) / (1f - s.handDeltaForwardDeadzone); + deltaElbowForward = (deltaElbowForward - Mathf.Sign(deltaElbowForward) * s.handDeltaForwardDeadzone) / (1 - s.handDeltaForwardDeadzone); } - deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180f; + deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180; interpolatedDeltaElbowForward = Mathf.LerpAngle(interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); float signedInterpolated = interpolatedDeltaElbowForward.toSignedEulerAngle(); @@ -335,11 +359,11 @@ class HandSettings float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); - elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90f, 90f); + elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90, 90); if (arm.wrist1 != null) - setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3f, lowerArmRotation * armDirection) * lowerArmRotation); + setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3, lowerArmRotation * armDirection) * lowerArmRotation); if (arm.wrist2 != null) - setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8f, lowerArmRotation * armDirection) * lowerArmRotation); + setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8, lowerArmRotation * armDirection) * lowerArmRotation); } setHandRotation(target.rotation); } From 28d0f2af1e38085c9d6c0d88f21e254d6fa2764f Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 12:53:01 -0400 Subject: [PATCH 025/562] More VRArmIk porting work --- vrarmik/ArmTransforms.js | 36 +- vrarmik/AvatarPlatformOffset.js | 2 +- vrarmik/AvatarVRTrackingReferences.js | 2 +- vrarmik/LocalVrTrackingInput.js | 2 +- vrarmik/PoseManager.js | 2 +- vrarmik/ShoulderPoser.js | 103 ++-- vrarmik/ShoulderTransforms.js | 101 +-- vrarmik/StaticOffsetTransform.js | 2 +- vrarmik/Utils/Extensions.js | 78 +-- vrarmik/Utils/InspectorAttributes.js | 26 +- vrarmik/Utils/VectorHelpers.js | 4 +- vrarmik/VRArmIK.js | 846 +++++++++++++------------- vrarmik/VRTrackingReferences.js | 20 +- 13 files changed, 625 insertions(+), 599 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 2747be0..31ffada 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,14 +1,26 @@ -class ArmTransforms +class ArmTransforms { - Transform upperArm, lowerArm, wrist1, wrist2, hand; + constructor() { + this.upperArm = new Transform(); + this.lowerArm = new Transform(); + this.wrist1 = new Transform(); + this.wrist2 = new Transform(); + this.hand = new Transform(); - float upperArmLength => distance(upperArm, lowerArm); - float lowerArmLength => distance(lowerArm, hand); - float armLength => upperArmLength + lowerArmLength; + this.armLengthByScale = false; + this.scaleAxis = Vector3.one; + this.scaleHandFactor = .7; + } - bool armLengthByScale = false; - Vector3 scaleAxis = Vector3.one; - float scaleHandFactor = .7f; + get upperArmLength() { + return distance(upperArm, lowerArm); + } + get lowerArmLength() { + return distance(lowerArm, hand); + } + get armLength() { + return upperArmLength + lowerArmLength; + } distance(Transform a, Transform b) { return (a.position - b.position).magnitude; @@ -23,7 +35,7 @@ updateArmLengths() { var shoulderWidth = (upperArm.position - lowerArm.position).magnitude; - var _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2f; + var _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2; setArmLength(_armLength); } @@ -63,16 +75,16 @@ setArmLength(float length) { - float upperArmFactor = .48f; + float upperArmFactor = .48; if (armLengthByScale) { upperArm.localScale = upperArm.localScale / armLength * length; - hand.localScale = Vector3.one / (1f - (1f - scaleHandFactor) * (1f - upperArm.localScale.x)); + hand.localScale = Vector3.one / (1 - (1 - scaleHandFactor) * (1 - upperArm.localScale.x)); } else { setUpperArmLength(length * upperArmFactor); - setLowerArmLength(length * (1f - upperArmFactor)); + setLowerArmLength(length * (1 - upperArmFactor)); } } } diff --git a/vrarmik/AvatarPlatformOffset.js b/vrarmik/AvatarPlatformOffset.js index cbc916b..dee5972 100644 --- a/vrarmik/AvatarPlatformOffset.js +++ b/vrarmik/AvatarPlatformOffset.js @@ -1,4 +1,4 @@ -using System.Collections; +using System.Collections; using System.Collections.Generic; using UnityEngine; using VRArmIK; diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index bb3bf38..35c0ba2 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,4 +1,4 @@ -using UnityEngine; +using UnityEngine; namespace VRArmIK { diff --git a/vrarmik/LocalVrTrackingInput.js b/vrarmik/LocalVrTrackingInput.js index abaea21..c663c91 100644 --- a/vrarmik/LocalVrTrackingInput.js +++ b/vrarmik/LocalVrTrackingInput.js @@ -1,4 +1,4 @@ -using System.Collections; +using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.VR; diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 62e14d3..754a768 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -1,4 +1,4 @@ -using UnityEngine; +using UnityEngine; using UnityEngine.XR; namespace VRArmIK diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index bc6cf61..532b71a 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,47 +1,52 @@ -class ShoulderPoser +import ShoulderTransforms from './ShoulderTransforms.js'; + +class ShoulderPoser { - ShoulderTransforms shoulder; - VRTrackingReferences vrTrackingReferences; - AvatarVRTrackingReferences avatarTrackingReferences; + constructor() { + this.shoulder = new ShoulderTransforms(); + this.vrTrackingReferences = new VRTrackingReferences(); + this.avatarTrackingReferences = AvatarVRTrackingReferences(); - float headNeckDistance = 0.03f; - Vector3 neckShoulderDistance = new Vector3(0f, -.1f, -0.02f); + this.headNeckDistance = 0.03; + this.neckShoulderDistance = new Vector3(0, -.1, -0.02); - float maxDeltaHeadRotation = 80f; + this.maxDeltaHeadRotation = 80; - float distinctShoulderRotationLimitForward = 33f; + this.distinctShoulderRotationLimitForward = 33; - float distinctShoulderRotationLimitBackward = 0f; + this.distinctShoulderRotationLimitBackward = 0; - float distinctShoulderRotationLimitUpward = 33f; - float distinctShoulderRotationMultiplier = 30; + this.distinctShoulderRotationLimitUpward = 33; + this.distinctShoulderRotationMultiplier = 30; - float rightRotationStartHeight = 0f; - float rightRotationHeightFactor = 142f; - float rightRotationHeadRotationFactor = 0.3f; - float rightRotationHeadRotationOffset = -20f; + this.rightRotationStartHeight = 0; + this.rightRotationHeightFactor = 142; + this.rightRotationHeadRotationFactor = 0.3; + this.rightRotationHeadRotationOffset = -20; - Vector3 headNeckDirectionVector = new Vector3(0f, -1f, -.05f); - float startShoulderDislocationBefore = 0.005f; + this.headNeckDirectionVector = new Vector3(0, -1, -.05); + this.startShoulderDislocationBefore = 0.005; - bool ignoreYPos = true; - bool autoDetectHandsBehindHead = true; - bool clampRotationToHead = true; - bool enableDistinctShoulderRotation = true; - bool enableShoulderDislocation = true; + this.ignoreYPos = true; + this.autoDetectHandsBehindHead = true; + this.clampRotationToHead = true; + this.enableDistinctShoulderRotation = true; + this.enableShoulderDislocation = true; - bool handsBehindHead = false; + this.handsBehindHead = false; - bool clampingHeadRotation = false; - bool shoulderDislocated = false; - float shoulderRightRotation; + this.clampingHeadRotation = false; + this.shoulderDislocated = false; + this.shoulderRightRotation; - Vector3 lastAngle = Vector3.zero; + this.lastAngle = Vector3.zero; - Vector3 leftShoulderAnkerStartLocalPosition, rightShoulderAnkerStartLocalPosition; + this.leftShoulderAnkerStartLocalPosition = new Vector3(); + this.rightShoulderAnkerStartLocalPosition = new Vector3(); + } Start() { @@ -90,14 +95,14 @@ rotateLeftShoulder() { rotateShoulderUp(shoulder.leftShoulder, shoulder.leftArm, avatarTrackingReferences.leftHand.transform, - leftShoulderAnkerStartLocalPosition, 1f); + leftShoulderAnkerStartLocalPosition, 1); } rotateRightShoulder() { rotateShoulderUp(shoulder.rightShoulder, shoulder.rightArm, avatarTrackingReferences.rightHand.transform, - rightShoulderAnkerStartLocalPosition, -1f); + rightShoulderAnkerStartLocalPosition, -1); } rotateShoulderUp(Transform shoulderSide, ArmTransforms arm, Transform targetHand, @@ -111,19 +116,19 @@ float forwardDistanceRatio = Vector3.Dot(handShoulderOffset, shoulder.transform.forward) / armLength; float upwardDistanceRatio = Vector3.Dot(handShoulderOffset, shoulder.transform.up) / armLength; - if (forwardDistanceRatio > 0f) + if (forwardDistanceRatio > 0) { - targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5f) * distinctShoulderRotationMultiplier, 0f, + targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5) * distinctShoulderRotationMultiplier, 0, distinctShoulderRotationLimitForward); } else { - targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08f) * distinctShoulderRotationMultiplier * 10f, - -distinctShoulderRotationLimitBackward, 0f); + targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08) * distinctShoulderRotationMultiplier * 10, + -distinctShoulderRotationLimitBackward, 0); } - targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5f) * distinctShoulderRotationMultiplier, - -distinctShoulderRotationLimitUpward, 0f); + targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5) * distinctShoulderRotationMultiplier, + -distinctShoulderRotationLimitUpward, 0); shoulderSide.localEulerAngles = targetAngle * angleSign; } @@ -141,7 +146,7 @@ { float angle = getCombinedDirectionAngleUp(); - Vector3 targetRotation = new Vector3(0f, angle, 0f); + Vector3 targetRotation = new Vector3(0, angle, 0); if (autoDetectHandsBehindHead) { @@ -164,11 +169,11 @@ float headRightRotation = VectorHelpers.getAngleBetween(shoulder.transform.forward, avatarTrackingReferences.hmd.transform.forward, Vector3.up, shoulder.transform.right) + rightRotationHeadRotationOffset; - float heightFactor = Mathf.Clamp(relativeHeightDiff - rightRotationStartHeight, 0f, 1f); + float heightFactor = Mathf.Clamp(relativeHeightDiff - rightRotationStartHeight, 0, 1); shoulderRightRotation = heightFactor * rightRotationHeightFactor; - shoulderRightRotation += Mathf.Clamp(headRightRotation * rightRotationHeadRotationFactor * heightFactor, 0f, 50f); + shoulderRightRotation += Mathf.Clamp(headRightRotation * rightRotationHeadRotationFactor * heightFactor, 0, 50); - shoulderRightRotation = Mathf.Clamp(shoulderRightRotation, 0f, 50f); + shoulderRightRotation = Mathf.Clamp(shoulderRightRotation, 0, 50); Quaternion deltaRot = Quaternion.AngleAxis(shoulderRightRotation, shoulder.transform.right); @@ -202,13 +207,13 @@ Vector3 combinedDirection = directionLeftHand + directionRightHand; - return Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180f / Mathf.PI; + return Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180 / Mathf.PI; } detectHandsBehindHead(ref Vector3 targetRotation) { - float delta = Mathf.Abs(targetRotation.y - lastAngle.y + 360f) % 360f; - if (delta > 150f && delta < 210f && lastAngle.magnitude > 0.000001f && !clampingHeadRotation) + float delta = Mathf.Abs(targetRotation.y - lastAngle.y + 360) % 360; + if (delta > 150 && delta < 210 && lastAngle.magnitude > 0.000001 && !clampingHeadRotation) { handsBehindHead = !handsBehindHead; } @@ -217,23 +222,23 @@ if (handsBehindHead) { - targetRotation.y += 180f; + targetRotation.y += 180; } } clampHeadRotationDeltaUp(ref Vector3 targetRotation) { - float headUpRotation = (avatarTrackingReferences.head.transform.eulerAngles.y + 360f) % 360f; - float targetUpRotation = (targetRotation.y + 360f) % 360f; + float headUpRotation = (avatarTrackingReferences.head.transform.eulerAngles.y + 360) % 360; + float targetUpRotation = (targetRotation.y + 360) % 360; float delta = headUpRotation - targetUpRotation; - if (delta > maxDeltaHeadRotation && delta < 180f || delta < -180f && delta >= -360f + maxDeltaHeadRotation) + if (delta > maxDeltaHeadRotation && delta < 180 || delta < -180 && delta >= -360 + maxDeltaHeadRotation) { targetRotation.y = headUpRotation - maxDeltaHeadRotation; clampingHeadRotation = true; } - else if (delta < -maxDeltaHeadRotation && delta > -180 || delta > 180f && delta < 360f - maxDeltaHeadRotation) + else if (delta < -maxDeltaHeadRotation && delta > -180 || delta > 180 && delta < 360 - maxDeltaHeadRotation) { targetRotation.y = headUpRotation + maxDeltaHeadRotation; clampingHeadRotation = true; @@ -251,7 +256,7 @@ float leftShoulderHandDistance = leftHandVector.magnitude, rightShoulderHandDistance = rightHandVector.magnitude; shoulderDislocated = false; - float startBeforeFactor = (1f - startShoulderDislocationBefore); + float startBeforeFactor = (1 - startShoulderDislocationBefore); if (leftShoulderHandDistance > shoulder.leftArm.armLength * startBeforeFactor) { diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index e1cfc28..d9b4be0 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -1,47 +1,56 @@ -class ShoulderTransforms - { - Transform leftShoulder, rightShoulder; - Transform leftShoulderRenderer, rightShoulderRenderer; - Transform leftShoulderAnchor, rightShoulderAnchor; - ArmTransforms leftArmDummy, rightArmDummy; - ArmTransforms leftArm, rightArm; - - Awake() - { - if (leftArm == null) - { - leftArm = Instantiate(leftArmDummy, leftShoulderAnchor.position, leftShoulderAnchor.rotation, leftShoulderAnchor); - var armIk = leftArm.GetComponentInChildren(); - armIk.shoulder = this; - armIk.shoulderPoser = GetComponent(); - armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; - } - if (rightArm == null) - { - rightArm = Instantiate(rightArmDummy, leftShoulderAnchor.position, rightShoulderAnchor.rotation, rightShoulderAnchor); - var armIk = rightArm.GetComponentInChildren(); - armIk.shoulder = this; - armIk.shoulderPoser = GetComponent(); - armIk.target = armIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; - } - } - - Start() - { - setShoulderWidth(PoseManager.Instance.playerWidthShoulders); - } - - setShoulderWidth(float width) - { - Vector3 localScale = new Vector3(width * .5f, .05f, .05f); - Vector3 localPosition = new Vector3(width * .25f, 0f, 0f); - - leftShoulderRenderer.localScale = localScale; - leftShoulderRenderer.localPosition = -localPosition; - - rightShoulderRenderer.localScale = localScale; - rightShoulderRenderer.localPosition = localPosition; - } - } - +import ArmTransforms from './ArmTransforms.js'; + +class ShoulderTransforms + { + constructor() { + this.leftShoulder = new Transform(); + this.rightShoulder = new Transform(); + this.leftShoulderRenderer = new Transform(); + this.rightShoulderRenderer = new Transform(); + this.leftShoulderAnchor = Transform(); + this.rightShoulderAnchor = Transform(); + this.leftArmDummy = new ArmTransforms(); + this.rightArmDummy = new ArmTransforms(); + this.leftArm = new ArmTransforms(); + this.rightArm = new ArmTransforms(); + } + + Awake() + { + if (leftArm == null) + { + leftArm = Instantiate(leftArmDummy, leftShoulderAnchor.position, leftShoulderAnchor.rotation, leftShoulderAnchor); + var armIk = leftArm.GetComponentInChildren(); + armIk.shoulder = this; + armIk.shoulderPoser = GetComponent(); + armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; + } + if (rightArm == null) + { + rightArm = Instantiate(rightArmDummy, leftShoulderAnchor.position, rightShoulderAnchor.rotation, rightShoulderAnchor); + var armIk = rightArm.GetComponentInChildren(); + armIk.shoulder = this; + armIk.shoulderPoser = GetComponent(); + armIk.target = armIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; + } + } + + Start() + { + setShoulderWidth(PoseManager.Instance.playerWidthShoulders); + } + + setShoulderWidth(float width) + { + Vector3 localScale = new Vector3(width * .5, .05, .05); + Vector3 localPosition = new Vector3(width * .25, 0, 0); + + leftShoulderRenderer.localScale = localScale; + leftShoulderRenderer.localPosition = -localPosition; + + rightShoulderRenderer.localScale = localScale; + rightShoulderRenderer.localPosition = localPosition; + } + } + export default ShoulderTransforms; \ No newline at end of file diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index 8d816a9..c8bc1dd 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -1,4 +1,4 @@ -using UnityEngine; +using UnityEngine; namespace VRArmIK { diff --git a/vrarmik/Utils/Extensions.js b/vrarmik/Utils/Extensions.js index c2df576..08b84b1 100644 --- a/vrarmik/Utils/Extensions.js +++ b/vrarmik/Utils/Extensions.js @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections; using System.Collections.Generic; using System.Linq; @@ -7,23 +7,23 @@ using UnityEngine.UI; using Random = UnityEngine.Random; -namespace VRArmIK +namespace VRArmIK { public static class LinqExtensions - { - public static void ForEach(this IEnumerable source, Action action) - { - foreach (var item in source) - action(item); + { + public static void ForEach(this IEnumerable source, Action action) + { + foreach (var item in source) + action(item); } } public static class UtilsExtensions - { - public static string F(this string self, params object[] objects) - { - return string.Format(self, objects); + { + public static string F(this string self, params object[] objects) + { + return string.Format(self, objects); } } @@ -155,22 +155,22 @@ namespace VRArmIK public static class ListExtensions { - public static T random(this List self) => self[(int)(self.Count * Random.value)]; - public static T next(this List self, int currentIndex, bool loop = false) - { - currentIndex++; - if (!loop && currentIndex >= self.Count) - { - throw new IndexOutOfRangeException(); - } - - currentIndex %= self.Count; - return self[currentIndex]; - } - - public static T next(this List self, T current, bool loop = false) - { - return self.next(self.IndexOf(current), loop); + public static T random(this List self) => self[(int)(self.Count * Random.value)]; + public static T next(this List self, int currentIndex, bool loop = false) + { + currentIndex++; + if (!loop && currentIndex >= self.Count) + { + throw new IndexOutOfRangeException(); + } + + currentIndex %= self.Count; + return self[currentIndex]; + } + + public static T next(this List self, T current, bool loop = false) + { + return self.next(self.IndexOf(current), loop); } } @@ -268,18 +268,18 @@ namespace VRArmIK self.alpha = 0f; } - } - - public static class IENumerableExtensions - { - public static T random(this IEnumerable self) - { - if (self.Count() == 0) - { - throw new IndexOutOfRangeException(); - } - return self.ElementAt(Random.Range(0, self.Count())); - } + } + + public static class IENumerableExtensions + { + public static T random(this IEnumerable self) + { + if (self.Count() == 0) + { + throw new IndexOutOfRangeException(); + } + return self.ElementAt(Random.Range(0, self.Count())); + } } public static class FloatExtensions diff --git a/vrarmik/Utils/InspectorAttributes.js b/vrarmik/Utils/InspectorAttributes.js index d319b07..235f6f2 100644 --- a/vrarmik/Utils/InspectorAttributes.js +++ b/vrarmik/Utils/InspectorAttributes.js @@ -1,14 +1,14 @@ -using UnityEngine; - -public class DisplayOnlyAttribute : PropertyAttribute -{ -} -public class LabelOverride : PropertyAttribute -{ - public string label; - public LabelOverride(string label) - { - this.label = label; - } - +using UnityEngine; + +public class DisplayOnlyAttribute : PropertyAttribute +{ +} +public class LabelOverride : PropertyAttribute +{ + public string label; + public LabelOverride(string label) + { + this.label = label; + } + } \ No newline at end of file diff --git a/vrarmik/Utils/VectorHelpers.js b/vrarmik/Utils/VectorHelpers.js index fb69917..aed02c1 100644 --- a/vrarmik/Utils/VectorHelpers.js +++ b/vrarmik/Utils/VectorHelpers.js @@ -1,6 +1,6 @@ -using UnityEngine; +using UnityEngine; -public static class VectorHelpers +public static class VectorHelpers { public static float axisAngle(Vector3 v, Vector3 forward, Vector3 axis) { diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index dafb873..14ac05f 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,424 +1,424 @@ -import ArmTransforms from './ArmTransforms.js'; -import ShoulderTransforms from './ShoulderTransforms.js'; -import ShoulderPoser from './ShoulderPoser.js'; - -class ArmIKElbowSettings -{ - constructor() { - this.calcElbowAngle = true; - this.clampElbowAngle = true; - this.softClampElbowAngle = true; - this.maxAngle = 175; - this.minAngle = 13; - this.softClampRange = 10; - this.offsetAngle = 135; - this.yWeight = -60; - this.zWeightTop = 260; - this.zWeightBottom = -100; - this.zBorderY = -.25; - this.zDistanceStart = .6; - this.xWeight = -50; - this.xDistanceStart = .1; - } -} - -class BeforePositioningSettings -{ - constructor() { - this.correctElbowOutside = true; - this.weight = -0.5; - this.startBelowZ = .4; - this.startAboveY = 0.1; - } -} - -class ElbowCorrectionSettings -{ - constructor() { - this.useFixedElbowWhenNearShoulder = true; - this.startBelowDistance = .5; - this.startBelowY = 0.1; - this.weight = 2; - this.localElbowPos = new Vector3(0.3, -1, -2); - } -} - -class HandSettings -{ - constructor() { - this.useWristRotation = true; - this.rotateElbowWithHandRight = true; - this.rotateElbowWithHandForward = true; - this.handDeltaPow = 1.5; - this.handDeltaFactor = -.3; - this.handDeltaOffset = 45; - // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] - this.handDeltaForwardPow = 2; - this.handDeltaForwardFactor = 1; - this.handDeltaForwardOffset = 0; - this.handDeltaForwardDeadzone = .3; - this.rotateElbowWithHandDelay = .08; - } -} - - class VRArmIK - { - constructor() { - this.arm = new ArmTransforms(); // XXX these need to be this'd below - this.shoulder = ShoulderTransforms(); - this.shoulderPoser = new ShoulderPoser(); - this.target = new Transform(); - this.left = true; - - this.elbowSettings = new ArmIKElbowSettings(); - this.beforePositioningSettings = new BeforePositioningSettings(); - this.elbowCorrectionSettings = ElbowCorrectionSettings(); - this.handSettings = new HandSettings(); - - this.nextLowerArmAngle = new Vector3(); - - this.upperArmStartRotation = new Quaternion(); - this.lowerArmStartRotation = new Quaternion(); - this.wristStartRotation = new Quaternion(); - this.handStartRotation = new Quaternion(); - - this.interpolatedDeltaElbow = 0; - this.interpolatedDeltaElbowForward = 0; - } - - Awake() - { - upperArmStartRotation = arm.upperArm.rotation; - lowerArmStartRotation = arm.lowerArm.rotation; - wristStartRotation = Quaternion.identity; - if (arm.wrist1 != null) - wristStartRotation = arm.wrist1.rotation; - handStartRotation = arm.hand.rotation; - } - - OnEnable() - { - setUpperArmRotation(Quaternion.identity); - setLowerArmRotation(Quaternion.identity); - setHandRotation(Quaternion.identity); - } - - LateUpdate() - { - updateUpperArmPosition(); - calcElbowInnerAngle(); - rotateShoulder(); - correctElbowRotation(); - if (elbowSettings.calcElbowAngle) - { - positionElbow(); - if (elbowCorrectionSettings.useFixedElbowWhenNearShoulder) - correctElbowAfterPositioning(); - if (handSettings.rotateElbowWithHandRight) - rotateElbowWithHandRight(); - if (handSettings.rotateElbowWithHandForward) - rotateElbowWithHandFoward(); - rotateHand(); - } - } - - updateArmAndTurnElbowUp() - { - updateUpperArmPosition(); - calcElbowInnerAngle(); - rotateShoulder(); - correctElbowRotation(); - } - - updateUpperArmPosition() - { - //arm.upperArm.position = shoulderAnker.transform.position; - } - - calcElbowInnerAngle() - { - Vector3 eulerAngles = new Vector3(); - float targetShoulderDistance = (target.position - upperArmPos).magnitude; - float innerAngle; - - if (targetShoulderDistance > arm.armLength) - { - innerAngle = 0; - } - else - { - innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(arm.upperArmLength, 2) + Mathf.Pow(arm.lowerArmLength, 2) - - Mathf.Pow(targetShoulderDistance, 2)) / (2 * arm.upperArmLength * arm.lowerArmLength), -1, 1)) * Mathf.Rad2Deg; - if (left) - innerAngle = 180 - innerAngle; - else - innerAngle = 180 + innerAngle; - if (float.IsNaN(innerAngle)) - { - innerAngle = 180; - } - } - - eulerAngles.y = innerAngle; - nextLowerArmAngle = eulerAngles; - } - - //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp - rotateShoulder() - { - Vector3 eulerAngles = new Vector3(); - Vector3 targetShoulderDirection = (target.position - upperArmPos).normalized; - float targetShoulderDistance = (target.position - upperArmPos).magnitude; - - eulerAngles.y = (left ? -1 : 1) * - Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(arm.upperArmLength, 2) - - Mathf.Pow(arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; - if (float.IsNaN(eulerAngles.y)) - eulerAngles.y = 0; - - - Quaternion shoulderRightRotation = Quaternion.FromToRotation(armDirection, targetShoulderDirection); - setUpperArmRotation(shoulderRightRotation); - arm.upperArm.rotation = Quaternion.AngleAxis(eulerAngles.y, lowerArmRotation * Vector3.up) * arm.upperArm.rotation; - setLowerArmLocalRotation(Quaternion.Euler(nextLowerArmAngle)); - } - - getElbowTargetAngle() - { - Vector3 localHandPosNormalized = shoulderAnker.InverseTransformPoint(handPos) / arm.armLength; - - // angle from Y - var angle = elbowSettings.yWeight * localHandPosNormalized.y + elbowSettings.offsetAngle; - - // angle from Z - /*angle += Mathf.Lerp(elbowSettings.zWeightBottom, elbowSettings.zWeightTop, Mathf.Clamp01((localHandPosNormalized.y + 1f) - elbowSettings.zBorderY)) * - (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f));*/ - if (localHandPosNormalized.y > 0) - angle += elbowSettings.zWeightTop * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(localHandPosNormalized.y, 0)); - else - angle += elbowSettings.zWeightBottom * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(-localHandPosNormalized.y, 0)); - - - // angle from X - angle += elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (left ? 1.0 : -1.0) + elbowSettings.xDistanceStart, 0); - - if (elbowSettings.clampElbowAngle) - { - if (elbowSettings.softClampElbowAngle) - { - if (angle < elbowSettings.minAngle + elbowSettings.softClampRange) - { - float a = elbowSettings.minAngle + elbowSettings.softClampRange - angle; - angle = elbowSettings.minAngle + elbowSettings.softClampRange * (1 - Mathf.Log(1 + a) * 3); - } - } - else - { - angle = Mathf.Clamp(angle, elbowSettings.minAngle, elbowSettings.maxAngle); - } - } - - if (left) - angle *= -1; - - return angle; - } - - correctElbowRotation() - { - var s = beforePositioningSettings; - - Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; - float elbowOutsideFactor = Mathf.Clamp01( - Mathf.Clamp01((s.startBelowZ - localTargetPos.z) / - Mathf.Abs(s.startBelowZ) * .5) * - Mathf.Clamp01((localTargetPos.y - s.startAboveY) / - Mathf.Abs(s.startAboveY)) * - Mathf.Clamp01(1 - localTargetPos.x * (left ? -1 : 1)) - ) * s.weight; - - Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; - Vector3 targetDir = shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (armDirection + Vector3.forward * -.2) * elbowOutsideFactor : Vector3.zero)); - Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000); - - Vector3 upperArmUp = upperArmRotation * Vector3.up; - - float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - float elbowAngle = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); - Quaternion rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); - arm.upperArm.rotation = rotation * arm.upperArm.rotation; - } - - /// - /// reduces calculation problems when hand is moving around shoulder XZ coordinates -> forces elbow to be outside of body - /// - correctElbowAfterPositioning() - { - var s = elbowCorrectionSettings; - Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; - Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; - Vector3 elbowPos = s.localElbowPos; - - if (left) - elbowPos.x *= -1; - - Vector3 targetDir = shoulder.transform.rotation * elbowPos.normalized; - Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir); - - Vector3 upperArmUp = upperArmRotation * Vector3.up; - - - Vector3 distance = target.position - upperArmPos; - distance = distance.magnitude * shoulder.transform.InverseTransformDirection(distance / distance.magnitude); - - float weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / arm.armLength) / - s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1) * 3)) * - Mathf.Clamp01((s.startBelowY - localTargetPos.y) / - s.startBelowY); - - float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - float elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); - Quaternion rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); - arm.upperArm.rotation = rotation * arm.upperArm.rotation; - } - - rotateElbow(float angle) - { - Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; - - Quaternion rotation = Quaternion.AngleAxis(angle, shoulderHandDirection); - setUpperArmRotation(rotation * upperArmRotation); - } - - //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp - positionElbow() - { - float targetElbowAngle = getElbowTargetAngle(); - rotateElbow(targetElbowAngle); - } - - - rotateElbowWithHandRight() - { - var s = handSettings; - Vector3 handUpVec = target.rotation * Vector3.up; - float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, - lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); - - // todo reduce influence if hand local forward rotation is high (hand tilted inside) - Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); - handUpVec = handForwardRotation * handUpVec; - - float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, - lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); - - float deltaElbow = (elbowTargetAngle + (left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180; - - deltaElbow = Mathf.Sign(deltaElbow) * Mathf.Pow(Mathf.Abs(deltaElbow), s.handDeltaPow) * 180 * s.handDeltaFactor; - interpolatedDeltaElbow = - Mathf.LerpAngle(interpolatedDeltaElbow, deltaElbow, Time.deltaTime / s.rotateElbowWithHandDelay); - rotateElbow(interpolatedDeltaElbow); - } - - rotateElbowWithHandFoward() - { - var s = handSettings; - Vector3 handRightVec = target.rotation * armDirection; - - float elbowTargetAngleForward = VectorHelpers.getAngleBetween(lowerArmRotation * armDirection, handRightVec, - lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); - - float deltaElbowForward = (elbowTargetAngleForward + (left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180; - - if (Mathf.Abs(deltaElbowForward) < s.handDeltaForwardDeadzone) - deltaElbowForward = 0; - else - { - deltaElbowForward = (deltaElbowForward - Mathf.Sign(deltaElbowForward) * s.handDeltaForwardDeadzone) / (1 - s.handDeltaForwardDeadzone); - } - - deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180; - interpolatedDeltaElbowForward = Mathf.LerpAngle(interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); - - float signedInterpolated = interpolatedDeltaElbowForward.toSignedEulerAngle(); - rotateElbow(signedInterpolated * s.handDeltaForwardFactor); - } - - rotateHand() - { - if (handSettings.useWristRotation) - { - Vector3 handUpVec = target.rotation * Vector3.up; - float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, - lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); - - // todo reduce influence if hand local forward rotation is high (hand tilted inside) - Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); - handUpVec = handForwardRotation * handUpVec; - - float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, - lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); - - elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90, 90); - if (arm.wrist1 != null) - setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3, lowerArmRotation * armDirection) * lowerArmRotation); - if (arm.wrist2 != null) - setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8, lowerArmRotation * armDirection) * lowerArmRotation); - } - setHandRotation(target.rotation); - } - - removeShoulderRightRotation(Vector3 direction) { - return Quaternion.AngleAxis(-shoulderPoser.shoulderRightRotation, shoulder.transform.right) * direction; - } - - get armDirection() { - return left ? Vector3.left : Vector3.right; - } - get upperArmPos() { - return arm.upperArm.position; - } - get lowerArmPos() { - return arm.lowerArm.position; - } - get handPos() { - return arm.hand.position; - } - get shoulderAnker() { - return left ? shoulder.leftShoulderAnchor : shoulder.rightShoulderAnchor; - } - - get upperArmRotation() { - return arm.upperArm.rotation * Quaternion.Inverse(upperArmStartRotation); - } - get lowerArmRotation() { - return arm.lowerArm.rotation * Quaternion.Inverse(lowerArmStartRotation); - } - get handRotation() { - return arm.hand.rotation * Quaternion.Inverse(handStartRotation); - } - - setUpperArmRotation(Quaternion rotation) { - return arm.upperArm.rotation = rotation * upperArmStartRotation; - } - setLowerArmRotation(Quaternion rotation) { - return arm.lowerArm.rotation = rotation * lowerArmStartRotation; - } - setLowerArmLocalRotation(Quaternion rotation) { - return arm.lowerArm.rotation = upperArmRotation * rotation * lowerArmStartRotation; - } - setWrist1Rotation(Quaternion rotation) { - return arm.wrist1.rotation = rotation * wristStartRotation; - } - setWrist2Rotation(Quaternion rotation) { - return arm.wrist2.rotation = rotation * wristStartRotation; - } - setWristLocalRotation(Quaternion rotation) { - return arm.wrist1.rotation = arm.lowerArm.rotation * rotation * wristStartRotation; - } - setHandRotation(Quaternion rotation) { - return arm.hand.rotation = arm.hand.rotation = rotation * handStartRotation; - } - } - +import ArmTransforms from './ArmTransforms.js'; +import ShoulderTransforms from './ShoulderTransforms.js'; +import ShoulderPoser from './ShoulderPoser.js'; + +class ArmIKElbowSettings +{ + constructor() { + this.calcElbowAngle = true; + this.clampElbowAngle = true; + this.softClampElbowAngle = true; + this.maxAngle = 175; + this.minAngle = 13; + this.softClampRange = 10; + this.offsetAngle = 135; + this.yWeight = -60; + this.zWeightTop = 260; + this.zWeightBottom = -100; + this.zBorderY = -.25; + this.zDistanceStart = .6; + this.xWeight = -50; + this.xDistanceStart = .1; + } +} + +class BeforePositioningSettings +{ + constructor() { + this.correctElbowOutside = true; + this.weight = -0.5; + this.startBelowZ = .4; + this.startAboveY = 0.1; + } +} + +class ElbowCorrectionSettings +{ + constructor() { + this.useFixedElbowWhenNearShoulder = true; + this.startBelowDistance = .5; + this.startBelowY = 0.1; + this.weight = 2; + this.localElbowPos = new Vector3(0.3, -1, -2); + } +} + +class HandSettings +{ + constructor() { + this.useWristRotation = true; + this.rotateElbowWithHandRight = true; + this.rotateElbowWithHandForward = true; + this.handDeltaPow = 1.5; + this.handDeltaFactor = -.3; + this.handDeltaOffset = 45; + // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] + this.handDeltaForwardPow = 2; + this.handDeltaForwardFactor = 1; + this.handDeltaForwardOffset = 0; + this.handDeltaForwardDeadzone = .3; + this.rotateElbowWithHandDelay = .08; + } +} + + class VRArmIK + { + constructor() { + this.arm = new ArmTransforms(); // XXX these need to be this'd below + this.shoulder = ShoulderTransforms(); + this.shoulderPoser = new ShoulderPoser(); + this.target = new Transform(); + this.left = true; + + this.elbowSettings = new ArmIKElbowSettings(); + this.beforePositioningSettings = new BeforePositioningSettings(); + this.elbowCorrectionSettings = ElbowCorrectionSettings(); + this.handSettings = new HandSettings(); + + this.nextLowerArmAngle = new Vector3(); + + this.upperArmStartRotation = new Quaternion(); + this.lowerArmStartRotation = new Quaternion(); + this.wristStartRotation = new Quaternion(); + this.handStartRotation = new Quaternion(); + + this.interpolatedDeltaElbow = 0; + this.interpolatedDeltaElbowForward = 0; + } + + Awake() + { + upperArmStartRotation = arm.upperArm.rotation; + lowerArmStartRotation = arm.lowerArm.rotation; + wristStartRotation = Quaternion.identity; + if (arm.wrist1 != null) + wristStartRotation = arm.wrist1.rotation; + handStartRotation = arm.hand.rotation; + } + + OnEnable() + { + setUpperArmRotation(Quaternion.identity); + setLowerArmRotation(Quaternion.identity); + setHandRotation(Quaternion.identity); + } + + LateUpdate() + { + updateUpperArmPosition(); + calcElbowInnerAngle(); + rotateShoulder(); + correctElbowRotation(); + if (elbowSettings.calcElbowAngle) + { + positionElbow(); + if (elbowCorrectionSettings.useFixedElbowWhenNearShoulder) + correctElbowAfterPositioning(); + if (handSettings.rotateElbowWithHandRight) + rotateElbowWithHandRight(); + if (handSettings.rotateElbowWithHandForward) + rotateElbowWithHandFoward(); + rotateHand(); + } + } + + updateArmAndTurnElbowUp() + { + updateUpperArmPosition(); + calcElbowInnerAngle(); + rotateShoulder(); + correctElbowRotation(); + } + + updateUpperArmPosition() + { + //arm.upperArm.position = shoulderAnker.transform.position; + } + + calcElbowInnerAngle() + { + Vector3 eulerAngles = new Vector3(); + float targetShoulderDistance = (target.position - upperArmPos).magnitude; + float innerAngle; + + if (targetShoulderDistance > arm.armLength) + { + innerAngle = 0; + } + else + { + innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(arm.upperArmLength, 2) + Mathf.Pow(arm.lowerArmLength, 2) - + Mathf.Pow(targetShoulderDistance, 2)) / (2 * arm.upperArmLength * arm.lowerArmLength), -1, 1)) * Mathf.Rad2Deg; + if (left) + innerAngle = 180 - innerAngle; + else + innerAngle = 180 + innerAngle; + if (float.IsNaN(innerAngle)) + { + innerAngle = 180; + } + } + + eulerAngles.y = innerAngle; + nextLowerArmAngle = eulerAngles; + } + + //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp + rotateShoulder() + { + Vector3 eulerAngles = new Vector3(); + Vector3 targetShoulderDirection = (target.position - upperArmPos).normalized; + float targetShoulderDistance = (target.position - upperArmPos).magnitude; + + eulerAngles.y = (left ? -1 : 1) * + Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(arm.upperArmLength, 2) - + Mathf.Pow(arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; + if (float.IsNaN(eulerAngles.y)) + eulerAngles.y = 0; + + + Quaternion shoulderRightRotation = Quaternion.FromToRotation(armDirection, targetShoulderDirection); + setUpperArmRotation(shoulderRightRotation); + arm.upperArm.rotation = Quaternion.AngleAxis(eulerAngles.y, lowerArmRotation * Vector3.up) * arm.upperArm.rotation; + setLowerArmLocalRotation(Quaternion.Euler(nextLowerArmAngle)); + } + + getElbowTargetAngle() + { + Vector3 localHandPosNormalized = shoulderAnker.InverseTransformPoint(handPos) / arm.armLength; + + // angle from Y + var angle = elbowSettings.yWeight * localHandPosNormalized.y + elbowSettings.offsetAngle; + + // angle from Z + /*angle += Mathf.Lerp(elbowSettings.zWeightBottom, elbowSettings.zWeightTop, Mathf.Clamp01((localHandPosNormalized.y + 1f) - elbowSettings.zBorderY)) * + (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f));*/ + if (localHandPosNormalized.y > 0) + angle += elbowSettings.zWeightTop * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(localHandPosNormalized.y, 0)); + else + angle += elbowSettings.zWeightBottom * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(-localHandPosNormalized.y, 0)); + + + // angle from X + angle += elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (left ? 1.0 : -1.0) + elbowSettings.xDistanceStart, 0); + + if (elbowSettings.clampElbowAngle) + { + if (elbowSettings.softClampElbowAngle) + { + if (angle < elbowSettings.minAngle + elbowSettings.softClampRange) + { + float a = elbowSettings.minAngle + elbowSettings.softClampRange - angle; + angle = elbowSettings.minAngle + elbowSettings.softClampRange * (1 - Mathf.Log(1 + a) * 3); + } + } + else + { + angle = Mathf.Clamp(angle, elbowSettings.minAngle, elbowSettings.maxAngle); + } + } + + if (left) + angle *= -1; + + return angle; + } + + correctElbowRotation() + { + var s = beforePositioningSettings; + + Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; + float elbowOutsideFactor = Mathf.Clamp01( + Mathf.Clamp01((s.startBelowZ - localTargetPos.z) / + Mathf.Abs(s.startBelowZ) * .5) * + Mathf.Clamp01((localTargetPos.y - s.startAboveY) / + Mathf.Abs(s.startAboveY)) * + Mathf.Clamp01(1 - localTargetPos.x * (left ? -1 : 1)) + ) * s.weight; + + Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; + Vector3 targetDir = shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (armDirection + Vector3.forward * -.2) * elbowOutsideFactor : Vector3.zero)); + Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000); + + Vector3 upperArmUp = upperArmRotation * Vector3.up; + + float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); + float elbowAngle = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); + Quaternion rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); + arm.upperArm.rotation = rotation * arm.upperArm.rotation; + } + + /// + /// reduces calculation problems when hand is moving around shoulder XZ coordinates -> forces elbow to be outside of body + /// + correctElbowAfterPositioning() + { + var s = elbowCorrectionSettings; + Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; + Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; + Vector3 elbowPos = s.localElbowPos; + + if (left) + elbowPos.x *= -1; + + Vector3 targetDir = shoulder.transform.rotation * elbowPos.normalized; + Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir); + + Vector3 upperArmUp = upperArmRotation * Vector3.up; + + + Vector3 distance = target.position - upperArmPos; + distance = distance.magnitude * shoulder.transform.InverseTransformDirection(distance / distance.magnitude); + + float weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / arm.armLength) / + s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1) * 3)) * + Mathf.Clamp01((s.startBelowY - localTargetPos.y) / + s.startBelowY); + + float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); + float elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); + Quaternion rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); + arm.upperArm.rotation = rotation * arm.upperArm.rotation; + } + + rotateElbow(float angle) + { + Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; + + Quaternion rotation = Quaternion.AngleAxis(angle, shoulderHandDirection); + setUpperArmRotation(rotation * upperArmRotation); + } + + //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp + positionElbow() + { + float targetElbowAngle = getElbowTargetAngle(); + rotateElbow(targetElbowAngle); + } + + + rotateElbowWithHandRight() + { + var s = handSettings; + Vector3 handUpVec = target.rotation * Vector3.up; + float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, + lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + + // todo reduce influence if hand local forward rotation is high (hand tilted inside) + Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); + handUpVec = handForwardRotation * handUpVec; + + float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, + lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); + + float deltaElbow = (elbowTargetAngle + (left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180; + + deltaElbow = Mathf.Sign(deltaElbow) * Mathf.Pow(Mathf.Abs(deltaElbow), s.handDeltaPow) * 180 * s.handDeltaFactor; + interpolatedDeltaElbow = + Mathf.LerpAngle(interpolatedDeltaElbow, deltaElbow, Time.deltaTime / s.rotateElbowWithHandDelay); + rotateElbow(interpolatedDeltaElbow); + } + + rotateElbowWithHandFoward() + { + var s = handSettings; + Vector3 handRightVec = target.rotation * armDirection; + + float elbowTargetAngleForward = VectorHelpers.getAngleBetween(lowerArmRotation * armDirection, handRightVec, + lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + + float deltaElbowForward = (elbowTargetAngleForward + (left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180; + + if (Mathf.Abs(deltaElbowForward) < s.handDeltaForwardDeadzone) + deltaElbowForward = 0; + else + { + deltaElbowForward = (deltaElbowForward - Mathf.Sign(deltaElbowForward) * s.handDeltaForwardDeadzone) / (1 - s.handDeltaForwardDeadzone); + } + + deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180; + interpolatedDeltaElbowForward = Mathf.LerpAngle(interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); + + float signedInterpolated = interpolatedDeltaElbowForward.toSignedEulerAngle(); + rotateElbow(signedInterpolated * s.handDeltaForwardFactor); + } + + rotateHand() + { + if (handSettings.useWristRotation) + { + Vector3 handUpVec = target.rotation * Vector3.up; + float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, + lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + + // todo reduce influence if hand local forward rotation is high (hand tilted inside) + Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); + handUpVec = handForwardRotation * handUpVec; + + float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, + lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); + + elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90, 90); + if (arm.wrist1 != null) + setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3, lowerArmRotation * armDirection) * lowerArmRotation); + if (arm.wrist2 != null) + setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8, lowerArmRotation * armDirection) * lowerArmRotation); + } + setHandRotation(target.rotation); + } + + removeShoulderRightRotation(Vector3 direction) { + return Quaternion.AngleAxis(-shoulderPoser.shoulderRightRotation, shoulder.transform.right) * direction; + } + + get armDirection() { + return left ? Vector3.left : Vector3.right; + } + get upperArmPos() { + return arm.upperArm.position; + } + get lowerArmPos() { + return arm.lowerArm.position; + } + get handPos() { + return arm.hand.position; + } + get shoulderAnker() { + return left ? shoulder.leftShoulderAnchor : shoulder.rightShoulderAnchor; + } + + get upperArmRotation() { + return arm.upperArm.rotation * Quaternion.Inverse(upperArmStartRotation); + } + get lowerArmRotation() { + return arm.lowerArm.rotation * Quaternion.Inverse(lowerArmStartRotation); + } + get handRotation() { + return arm.hand.rotation * Quaternion.Inverse(handStartRotation); + } + + setUpperArmRotation(Quaternion rotation) { + return arm.upperArm.rotation = rotation * upperArmStartRotation; + } + setLowerArmRotation(Quaternion rotation) { + return arm.lowerArm.rotation = rotation * lowerArmStartRotation; + } + setLowerArmLocalRotation(Quaternion rotation) { + return arm.lowerArm.rotation = upperArmRotation * rotation * lowerArmStartRotation; + } + setWrist1Rotation(Quaternion rotation) { + return arm.wrist1.rotation = rotation * wristStartRotation; + } + setWrist2Rotation(Quaternion rotation) { + return arm.wrist2.rotation = rotation * wristStartRotation; + } + setWristLocalRotation(Quaternion rotation) { + return arm.wrist1.rotation = arm.lowerArm.rotation * rotation * wristStartRotation; + } + setHandRotation(Quaternion rotation) { + return arm.hand.rotation = arm.hand.rotation = rotation * handStartRotation; + } + } + export default VRArmIK; \ No newline at end of file diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index c703d31..dcadcf3 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -1,11 +1,11 @@ -using UnityEngine; - -namespace VRArmIK -{ - - public class VRTrackingReferences : MonoBehaviour - { - public Transform leftController, rightController, hmd; - public Transform leftHand, rightHand, head; - } +using UnityEngine; + +namespace VRArmIK +{ + + public class VRTrackingReferences : MonoBehaviour + { + public Transform leftController, rightController, hmd; + public Transform leftHand, rightHand, head; + } } \ No newline at end of file From 250e8fbb6f7e49485cfc7817f5e6fa23301a0afd Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 13:00:44 -0400 Subject: [PATCH 026/562] Remove dead LocalVrTrackingInput.js --- vrarmik/LocalVrTrackingInput.js | 21 --------------------- 1 file changed, 21 deletions(-) delete mode 100644 vrarmik/LocalVrTrackingInput.js diff --git a/vrarmik/LocalVrTrackingInput.js b/vrarmik/LocalVrTrackingInput.js deleted file mode 100644 index c663c91..0000000 --- a/vrarmik/LocalVrTrackingInput.js +++ /dev/null @@ -1,21 +0,0 @@ -using System.Collections; -using System.Collections.Generic; -using UnityEngine; -using UnityEngine.VR; - -namespace VRArmIK -{ - public class LocalVrTrackingInput : MonoBehaviour - { - public UnityEngine.XR.XRNode node; - - void Update() - { - if (UnityEngine.XR.InputTracking.GetLocalPosition(node).magnitude < 0.000001f) - return; - - transform.localPosition = UnityEngine.XR.InputTracking.GetLocalPosition(node); - transform.localRotation = UnityEngine.XR.InputTracking.GetLocalRotation(node); - } - } -} \ No newline at end of file From e708b95fd84af243cc2aa47878188f6aa95db107 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 13:10:02 -0400 Subject: [PATCH 027/562] More porting work --- vrarmik/AvatarVRTrackingReferences.js | 30 ++++++------ vrarmik/PoseManager.js | 62 +++++++++++------------- vrarmik/ShoulderPoser.js | 1 + vrarmik/StaticOffsetTransform.js | 68 +++++++++++++-------------- vrarmik/VRTrackingReferences.js | 18 +++---- 5 files changed, 88 insertions(+), 91 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 35c0ba2..b167b5e 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,24 +1,25 @@ -using UnityEngine; -namespace VRArmIK -{ - public class AvatarVRTrackingReferences : MonoBehaviour + class AvatarVRTrackingReferences { - public StaticOffsetTransform head, hmd, leftHand, rightHand; + constructor() { + this.head = new StaticOffsetTransform(); + this.hmd = new StaticOffsetTransform(); + this.leftHand = new StaticOffsetTransform(); + this.rightHand = new StaticOffsetTransform(); + } - void Start() + Start() { initTransforms(); } - [ContextMenu("init transforms")] - public void initTransforms() + initTransforms() { createTransforms(); connectTransforms(); } - void setStaticOffsetSettings(StaticOffsetTransform s) + setStaticOffsetSettings(StaticOffsetTransform s) { s.referenceLocalPosition = false; s.referenceLocalRotation = false; @@ -30,7 +31,7 @@ namespace VRArmIK } - void createTransform(ref StaticOffsetTransform t, string name) + createTransform(ref StaticOffsetTransform t, string name) { if (t == null) { @@ -40,7 +41,7 @@ namespace VRArmIK } } - void createHandTransform(ref Transform t, string name, Transform parent) + createHandTransform(ref Transform t, string name, Transform parent) { if (t == null) { @@ -50,7 +51,7 @@ namespace VRArmIK } } - void createTransforms() + createTransforms() { createTransform(ref head, nameof(head)); createTransform(ref leftHand, nameof(leftHand)); @@ -58,7 +59,7 @@ namespace VRArmIK createTransform(ref hmd, nameof(hmd)); } - void connectTransforms() + connectTransforms() { StaticOffsetTransform sot = this.GetOrAddComponent(); if (sot.reference == null) @@ -76,4 +77,5 @@ namespace VRArmIK : PoseManager.Instance.vrTransforms.rightHand; } } -} \ No newline at end of file + +export default AvatarVRTrackingReferences; \ No newline at end of file diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 754a768..c8c4f64 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -1,30 +1,24 @@ -using UnityEngine; -using UnityEngine.XR; +import VRTrackingReferences from './VRTrackingReferences.js'; -namespace VRArmIK -{ - [ExecuteInEditMode] - public class PoseManager : MonoBehaviour +class PoseManager { - public static PoseManager Instance = null; - public VRTrackingReferences vrTransforms; + constructor() { + this.vrTransforms = new VRTrackingReferences(); + this.OnCalibrateListener = null; - public delegate void OnCalibrateListener(); + // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. + // In OpenVR, the 0 position is the ground position and the user is then at (0, playerHeightHmd, 0) if he is in the middle of the room, so I need to correct this for shoulder calculation + this.vrSystemOffsetHeight = 0.0; - public event OnCalibrateListener onCalibrate; + this.referencePlayerHeightHmd = 1.7; + this.referencePlayerWidthWrist = 1.39; + this.playerHeightHmd = 1.70; + this.playerWidthWrist = 1.39; + this.playerWidthShoulders = 0.31; + this.loadPlayerSizeOnAwake = false; + } - // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. - // In OpenVR, the 0 position is the ground position and the user is then at (0, playerHeightHmd, 0) if he is in the middle of the room, so I need to correct this for shoulder calculation - public float vrSystemOffsetHeight = 0.0f; - - public const float referencePlayerHeightHmd = 1.7f; - public const float referencePlayerWidthWrist = 1.39f; - public float playerHeightHmd = 1.70f; - public float playerWidthWrist = 1.39f; - public float playerWidthShoulders = 0.31f; - public bool loadPlayerSizeOnAwake = false; - - void OnEnable() + OnEnable() { if (Instance == null) { @@ -36,7 +30,7 @@ namespace VRArmIK } } - void Awake() + Awake() { if (loadPlayerSizeOnAwake) { @@ -46,36 +40,34 @@ namespace VRArmIK vrSystemOffsetHeight = string.IsNullOrEmpty(device) || device == "OpenVR" ? 0 : playerHeightHmd; } - void Start() + Start() { onCalibrate += OnCalibrate; } - [ContextMenu("calibrate")] - void OnCalibrate() + OnCalibrate() { playerHeightHmd = Camera.main.transform.position.y; } - void loadPlayerWidthShoulders() + loadPlayerWidthShoulders() { - playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31f); + playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31); } - public void savePlayerWidthShoulders(float width) + savePlayerWidthShoulders(float width) { PlayerPrefs.SetFloat("VRArmIK_PlayerWidthShoulders", width); } - [ContextMenu("setArmLength")] - public void calibrateIK() + calibrateIK() { playerWidthWrist = (vrTransforms.leftHand.position - vrTransforms.rightHand.position).magnitude; playerHeightHmd = vrTransforms.hmd.position.y; savePlayerSize(playerHeightHmd, playerWidthWrist); } - public void savePlayerSize(float heightHmd, float widthWrist) + savePlayerSize(float heightHmd, float widthWrist) { PlayerPrefs.SetFloat("VRArmIK_PlayerHeightHmd", heightHmd); PlayerPrefs.SetFloat("VRArmIK_PlayerWidthWrist", widthWrist); @@ -83,10 +75,12 @@ namespace VRArmIK onCalibrate?.Invoke(); } - public void loadPlayerSize() + loadPlayerSize() { playerHeightHmd = PlayerPrefs.GetFloat("VRArmIK_PlayerHeightHmd", referencePlayerHeightHmd); playerWidthWrist = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthWrist", referencePlayerWidthWrist); } } -} \ No newline at end of file + PoseManager.Instance = null; + +export default PoseManager; \ No newline at end of file diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 532b71a..e9f7079 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,4 +1,5 @@ import ShoulderTransforms from './ShoulderTransforms.js'; +import VRTrackingReferences from './VRTrackingReferences.js'; class ShoulderPoser { diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index c8bc1dd..b6a1b7c 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -1,34 +1,33 @@ -using UnityEngine; - -namespace VRArmIK -{ - public class StaticOffsetTransform : MonoBehaviour +const EulerOrder = { + XYZ: 'XYZ', + XZY: 'XZY', + YXZ: 'YXZ', + YZX: 'YZX', + ZXY: 'ZXY', + ZYX: 'ZYX', +}; + +class StaticOffsetTransform { - public enum EulerOrder - { - XYZ, - XZY, - YXZ, - YZX, - ZXY, - ZYX - }; - - public Transform reference = null; - public Vector3 offsetPosition; - public Vector3 offsetRotation; - public Vector3 orientationalOffset; - public Vector3 referenceRotationMultiplicator = Vector3.one; - - public EulerOrder axisOrder; - - public bool referenceLocalPosition = false, referenceLocalRotation = false; - public bool applyLocalPosition = false, applyLocalRotation = false; - public bool applyPosition = true, applyRotation = true; - public bool applyForwardOffsetAfterRotationOffset = false; - - - public static Vector3 switchAxis(Vector3 r, EulerOrder order) + constructor() { + this.reference = null; + this.offsetPosition = new Vector3(); + this.offsetRotation = new Vector3(); + this.orientationalOffset = new Vector3(); + this.referenceRotationMultiplicator = Vector3.one; + + this.axisOrder = new EulerOrder(); + + this.referenceLocalPosition = false; + this.referenceLocalRotation = false; + this.applyLocalPosition = false; + this.applyLocalRotation = false; + this.applyPosition = true; + this.applyRotation = true; + this.applyForwardOffsetAfterRotationOffset = false; + } + + switchAxis(Vector3 r, EulerOrder order) { switch (order) { @@ -50,17 +49,17 @@ namespace VRArmIK } } - void Awake() + Awake() { updatePosition(); } - void Update() + Update() { updatePosition(); } - void updatePosition() + updatePosition() { if (reference == null) return; @@ -113,4 +112,5 @@ namespace VRArmIK } } } -} \ No newline at end of file + +export default StaticOffsetTransform; \ No newline at end of file diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index dcadcf3..861c2e2 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -1,11 +1,11 @@ -using UnityEngine; - -namespace VRArmIK -{ - - public class VRTrackingReferences : MonoBehaviour + class VRTrackingReferences { - public Transform leftController, rightController, hmd; - public Transform leftHand, rightHand, head; + this.leftController = new Transform(); + this.rightController = new Transform(); + this.hmd = new Transform(); + this.leftHand = new Transform(); + this.rightHand = new Transform(); + this.head = new Transform(); } -} \ No newline at end of file + +export default VRTrackingReferences; \ No newline at end of file From cc507abfc9cee94c0fbcfda8b0c6067eea5edd63 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 13:21:18 -0400 Subject: [PATCH 028/562] Remove dead utils files --- vrarmik/Utils/Editor.meta | 10 - .../Editor/LabelOverrideInspector.cs.meta | 13 - .../Utils/Editor/LabelOverrideInspector.js | 13 - .../Utils/Editor/ReadOnlyInspector.cs.meta | 13 - vrarmik/Utils/Editor/ReadOnlyInspector.js | 39 --- vrarmik/Utils/Extensions.cs.meta | 13 - vrarmik/Utils/Extensions.js | 301 ------------------ vrarmik/Utils/InspectorAttributes.cs.meta | 13 - vrarmik/Utils/InspectorAttributes.js | 14 - vrarmik/Utils/VectorHelpers.cs.meta | 13 - 10 files changed, 442 deletions(-) delete mode 100644 vrarmik/Utils/Editor.meta delete mode 100644 vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta delete mode 100644 vrarmik/Utils/Editor/LabelOverrideInspector.js delete mode 100644 vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta delete mode 100644 vrarmik/Utils/Editor/ReadOnlyInspector.js delete mode 100644 vrarmik/Utils/Extensions.cs.meta delete mode 100644 vrarmik/Utils/Extensions.js delete mode 100644 vrarmik/Utils/InspectorAttributes.cs.meta delete mode 100644 vrarmik/Utils/InspectorAttributes.js delete mode 100644 vrarmik/Utils/VectorHelpers.cs.meta diff --git a/vrarmik/Utils/Editor.meta b/vrarmik/Utils/Editor.meta deleted file mode 100644 index 99d9d7a..0000000 --- a/vrarmik/Utils/Editor.meta +++ /dev/null @@ -1,10 +0,0 @@ -fileFormatVersion: 2 -guid: ff05c1415d8afee45b3616972c5e311b -folderAsset: yes -timeCreated: 1528126517 -licenseType: Free -DefaultImporter: - externalObjects: {} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta b/vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta deleted file mode 100644 index 564a570..0000000 --- a/vrarmik/Utils/Editor/LabelOverrideInspector.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 3a301e6db22cc5747b54c20deee95547 -timeCreated: 1528126534 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/Utils/Editor/LabelOverrideInspector.js b/vrarmik/Utils/Editor/LabelOverrideInspector.js deleted file mode 100644 index a808af9..0000000 --- a/vrarmik/Utils/Editor/LabelOverrideInspector.js +++ /dev/null @@ -1,13 +0,0 @@ -using UnityEngine; -using UnityEditor; - -[CustomPropertyDrawer(typeof(LabelOverride))] -public class ThisPropertyDrawer : PropertyDrawer -{ - public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) - { - var propertyAttribute = attribute as LabelOverride; - label.text = propertyAttribute?.label; - EditorGUI.PropertyField(position, property, label); - } -} \ No newline at end of file diff --git a/vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta b/vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta deleted file mode 100644 index 5944573..0000000 --- a/vrarmik/Utils/Editor/ReadOnlyInspector.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 995d6e718b3990448939a03e8c25bbf2 -timeCreated: 1528126534 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/Utils/Editor/ReadOnlyInspector.js b/vrarmik/Utils/Editor/ReadOnlyInspector.js deleted file mode 100644 index 3443cbb..0000000 --- a/vrarmik/Utils/Editor/ReadOnlyInspector.js +++ /dev/null @@ -1,39 +0,0 @@ -using System.ComponentModel; -using UnityEditor; -using UnityEngine; - -[CustomPropertyDrawer(typeof(DisplayOnlyAttribute))] -public class DisplayOnlyInspector : PropertyDrawer -{ - public override void OnGUI(Rect position, SerializedProperty prop, GUIContent label) - { - string valueStr; - - switch (prop.propertyType) - { - case SerializedPropertyType.Integer: - valueStr = prop.intValue.ToString(); - break; - case SerializedPropertyType.Boolean: - valueStr = prop.boolValue.ToString(); - break; - case SerializedPropertyType.Float: - valueStr = prop.floatValue.ToString("0.00000"); - break; - case SerializedPropertyType.String: - valueStr = prop.stringValue; - break; - case SerializedPropertyType.Vector2: - valueStr = prop.vector2Value.ToString(); - break; - case SerializedPropertyType.Vector3: - valueStr = prop.vector3Value.ToString(); - break; - default: - valueStr = "(not supported)"; - break; - } - - EditorGUI.LabelField(position, label.text, valueStr); - } -} \ No newline at end of file diff --git a/vrarmik/Utils/Extensions.cs.meta b/vrarmik/Utils/Extensions.cs.meta deleted file mode 100644 index 8db612c..0000000 --- a/vrarmik/Utils/Extensions.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: dd40c275b2b3c5042bee83817b9d5277 -timeCreated: 1528126366 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/Utils/Extensions.js b/vrarmik/Utils/Extensions.js deleted file mode 100644 index 08b84b1..0000000 --- a/vrarmik/Utils/Extensions.js +++ /dev/null @@ -1,301 +0,0 @@ -using System; -using System.Collections; -using System.Collections.Generic; -using System.Linq; -using UnityEngine; -using UnityEngine.UI; -using Random = UnityEngine.Random; - - -namespace VRArmIK -{ - - public static class LinqExtensions - { - public static void ForEach(this IEnumerable source, Action action) - { - foreach (var item in source) - action(item); - } - } - - public static class UtilsExtensions - { - public static string F(this string self, params object[] objects) - { - return string.Format(self, objects); - } - } - - public static class TransformExtensions - { - public static void SetParentForReal(this Transform self, Transform parent) - { - self.SetParent(parent); - self.localScale = Vector3.one; - } - } - - public static class MonoBehaviourExtensions - { - public static T GetOrAddComponent(this Component self) where T : Component - { - T component = self.GetComponent(); - return component != null ? component : self.gameObject.AddComponent(); - } - - public static T GetOrAddComponentInChildren(this MonoBehaviour self) where T : MonoBehaviour - { - T component = self.GetComponentInChildren(); - return component != null ? component : self.gameObject.AddComponent(); - } - } - - - public static class LayerMaskExtensions - { - public static LayerMask Create(params string[] layerNames) - { - return NamesToMask(layerNames); - } - - public static LayerMask Create(params int[] layerNumbers) - { - return LayerNumbersToMask(layerNumbers); - } - - public static LayerMask NamesToMask(params string[] layerNames) - { - LayerMask ret = (LayerMask)0; - foreach (var name in layerNames) - { - ret |= (1 << LayerMask.NameToLayer(name)); - } - - return ret; - } - - public static LayerMask LayerNumbersToMask(params int[] layerNumbers) - { - LayerMask ret = (LayerMask)0; - foreach (var layer in layerNumbers) - { - ret |= (1 << layer); - } - return ret; - } - - public static LayerMask Inverse(this LayerMask original) - { - return ~original; - } - - public static LayerMask AddToMask(this LayerMask original, params string[] layerNames) - { - return original | NamesToMask(layerNames); - } - - public static LayerMask RemoveFromMask(this LayerMask original, params string[] layerNames) - { - return original & ~NamesToMask(layerNames); - } - - public static string[] MaskToNames(this LayerMask original) - { - var output = new List(); - - for (int i = 0; i < 32; ++i) - { - int shifted = 1 << i; - if ((original & shifted) == shifted) - { - string layerName = LayerMask.LayerToName(i); - if (!string.IsNullOrEmpty(layerName)) - { - output.Add(layerName); - } - } - } - return output.ToArray(); - } - - public static string MaskToString(this LayerMask original) - { - return MaskToString(original, ", "); - } - - public static string MaskToString(this LayerMask original, string delimiter) - { - return string.Join(delimiter, MaskToNames(original)); - } - } - - public static class VectorExtensions - { - public static Vector3 toVector3(this Vector2 self) - { - return new Vector3(self.x, self.y); - } - - public static Vector2 xy(this Vector3 self) - { - return new Vector2(self.x, self.y); - } - - public static Vector2 xz(this Vector3 self) - { - return new Vector2(self.x, self.z); - } - - public static Vector2 yz(this Vector3 self) - { - return new Vector2(self.y, self.y); - } - } - - public static class ListExtensions - { - public static T random(this List self) => self[(int)(self.Count * Random.value)]; - public static T next(this List self, int currentIndex, bool loop = false) - { - currentIndex++; - if (!loop && currentIndex >= self.Count) - { - throw new IndexOutOfRangeException(); - } - - currentIndex %= self.Count; - return self[currentIndex]; - } - - public static T next(this List self, T current, bool loop = false) - { - return self.next(self.IndexOf(current), loop); - } - } - - - public static class RandomExtensions - { - public static Vector2 insideUnitCircle(this System.Random self) - { - float radius = (float)self.NextDouble(); - float angle = (float)self.NextDouble() * Mathf.PI * 2; - - return new Vector2(Mathf.Cos(angle) * radius, Mathf.Sin(angle) * radius); - } - - public static float range(this System.Random self, float min, float max) - { - return (float)(self.NextDouble() * (max - min) + min); - } - - public static Vector3 insideUnitCube(this System.Random self) - { - return new Vector3(self.range(-1f, 1f), self.range(-1f, 1f), self.range(-1f, 1f)); - } - } - - public static class EnumExtenstions - { - public class Enum where T : struct, IConvertible - { - public static int Count - { - get - { - if (!typeof(T).IsEnum) - throw new ArgumentException("T must be an enumerated type"); - - return Enum.GetNames(typeof(T)).Length; - } - } - } - - public static T Next(this T src) where T : struct - { - if (!typeof(T).IsEnum) throw new ArgumentException($"Argumnent {typeof(T).FullName} is not an Enum"); - - T[] Arr = (T[])Enum.GetValues(src.GetType()); - int j = Array.IndexOf(Arr, src) + 1; - return Arr.Length == j ? Arr[0] : Arr[j]; - } - - public static bool IsLast(this T src) where T : struct - { - if (!typeof(T).IsEnum) throw new ArgumentException($"Argumnent {typeof(T).FullName} is not an Enum"); - - T[] Arr = (T[])Enum.GetValues(src.GetType()); - int j = Array.IndexOf(Arr, src); - return Arr.Length == j + 1; - } - } - - public static class UIExtensions - { - public static void setNormalButtonColor(this Button self, Color color) - { - - var buttonColors = self.colors; - buttonColors.normalColor = color; - self.colors = buttonColors; - } - - public static IEnumerator fadeIn(this CanvasGroup self, float duration) - { - float timePassed = 0.0f; - - while (timePassed < duration) - { - self.alpha = timePassed / duration; - timePassed += Time.unscaledDeltaTime; - yield return null; - } - - self.alpha = 1f; - } - - public static IEnumerator fadeOut(this CanvasGroup self, float duration) - { - float timePassed = 0.0f; - - while (timePassed < duration) - { - self.alpha = 1f - timePassed / duration; - timePassed += Time.unscaledDeltaTime; - yield return null; - } - - self.alpha = 0f; - } - } - - public static class IENumerableExtensions - { - public static T random(this IEnumerable self) - { - if (self.Count() == 0) - { - throw new IndexOutOfRangeException(); - } - return self.ElementAt(Random.Range(0, self.Count())); - } - } - - public static class FloatExtensions - { - public static float toSignedEulerAngle(this float self) - { - float result = self.toPositiveEulerAngle(); - if (result > 180f) - result = result - 360f; - return result; - } - - public static float toPositiveEulerAngle(this float self) - { - float result = (self % 360f + 360f) % 360f; - return result; - } - } -} \ No newline at end of file diff --git a/vrarmik/Utils/InspectorAttributes.cs.meta b/vrarmik/Utils/InspectorAttributes.cs.meta deleted file mode 100644 index 3e7f3ba..0000000 --- a/vrarmik/Utils/InspectorAttributes.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: a729eda56804e2043ac3fc58960a13bb -timeCreated: 1528126528 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: diff --git a/vrarmik/Utils/InspectorAttributes.js b/vrarmik/Utils/InspectorAttributes.js deleted file mode 100644 index 235f6f2..0000000 --- a/vrarmik/Utils/InspectorAttributes.js +++ /dev/null @@ -1,14 +0,0 @@ -using UnityEngine; - -public class DisplayOnlyAttribute : PropertyAttribute -{ -} -public class LabelOverride : PropertyAttribute -{ - public string label; - public LabelOverride(string label) - { - this.label = label; - } - -} \ No newline at end of file diff --git a/vrarmik/Utils/VectorHelpers.cs.meta b/vrarmik/Utils/VectorHelpers.cs.meta deleted file mode 100644 index 2c65cb4..0000000 --- a/vrarmik/Utils/VectorHelpers.cs.meta +++ /dev/null @@ -1,13 +0,0 @@ -fileFormatVersion: 2 -guid: 56770d9500874ac4d8980df3b398f7ee -timeCreated: 1528126637 -licenseType: Free -MonoImporter: - externalObjects: {} - serializedVersion: 2 - defaultReferences: [] - executionOrder: 0 - icon: {instanceID: 0} - userData: - assetBundleName: - assetBundleVariant: From 44c612b3d51f08fd0149c5d47268842b7959f41e Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 13:23:01 -0400 Subject: [PATCH 029/562] Port vrarmik VectorHelpers --- vrarmik/Utils/VectorHelpers.js | 18 ++++++++---------- vrarmik/VRArmIK.js | 1 + 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/vrarmik/Utils/VectorHelpers.js b/vrarmik/Utils/VectorHelpers.js index aed02c1..dfb63a9 100644 --- a/vrarmik/Utils/VectorHelpers.js +++ b/vrarmik/Utils/VectorHelpers.js @@ -1,19 +1,17 @@ -using UnityEngine; - -public static class VectorHelpers -{ - public static float axisAngle(Vector3 v, Vector3 forward, Vector3 axis) +const VectorHelpers = { + axisAngle(Vector3 v, Vector3 forward, Vector3 axis) { Vector3 right = Vector3.Cross(axis, forward); forward = Vector3.Cross(right, axis); return Mathf.Atan2(Vector3.Dot(v, right), Vector3.Dot(v, forward)) * Mathf.Rad2Deg; - } - - public static float getAngleBetween(Vector3 a, Vector3 b, Vector3 forward, Vector3 axis) + }, + getAngleBetween(Vector3 a, Vector3 b, Vector3 forward, Vector3 axis) { float angleA = axisAngle(a, forward, axis); float angleB = axisAngle(b, forward, axis); return Mathf.DeltaAngle(angleA, angleB); - } -} + }, +}; + +export default VectorHelpers; \ No newline at end of file diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 14ac05f..1ded3e1 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,6 +1,7 @@ import ArmTransforms from './ArmTransforms.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; +import VectorHelpers from 'Utils/VectorHelpers.js'; class ArmIKElbowSettings { From b7c4b17d2c7eb5a36c774cde241650c9885b3e41 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 14:47:07 -0400 Subject: [PATCH 030/562] Small vrarmik cleanup --- vrarmik/VRArmIK.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 1ded3e1..dde97a0 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -66,7 +66,7 @@ class HandSettings { constructor() { this.arm = new ArmTransforms(); // XXX these need to be this'd below - this.shoulder = ShoulderTransforms(); + this.shoulder = new ShoulderTransforms(); this.shoulderPoser = new ShoulderPoser(); this.target = new Transform(); this.left = true; @@ -422,4 +422,4 @@ class HandSettings } } -export default VRArmIK; \ No newline at end of file +export default VRArmIK; From 07b8baf3300c09c788a71a2922709313150bea7d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 20:45:47 -0400 Subject: [PATCH 031/562] Add initial Transform.js --- vrarmik/Transform.js | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 vrarmik/Transform.js diff --git a/vrarmik/Transform.js b/vrarmik/Transform.js new file mode 100644 index 0000000..5b74539 --- /dev/null +++ b/vrarmik/Transform.js @@ -0,0 +1,9 @@ +class Transform { + constructor() { + this.position = new Vector3(); + this.rotation = new Quaternion(); + this.scale = new Vector3(1, 1, 1); + } +} + +export default Transform; From 0e5a5eb1266a11dc358c71e06a25dfc8d5860df1 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 22:49:08 -0400 Subject: [PATCH 032/562] Remove dead AvatarPlatformOffset --- vrarmik/AvatarPlatformOffset.js | 19 ------------------- vrarmik/{Transform.js => Unity.js} | 0 2 files changed, 19 deletions(-) delete mode 100644 vrarmik/AvatarPlatformOffset.js rename vrarmik/{Transform.js => Unity.js} (100%) diff --git a/vrarmik/AvatarPlatformOffset.js b/vrarmik/AvatarPlatformOffset.js deleted file mode 100644 index dee5972..0000000 --- a/vrarmik/AvatarPlatformOffset.js +++ /dev/null @@ -1,19 +0,0 @@ -using System.Collections; -using System.Collections.Generic; -using UnityEngine; -using VRArmIK; - -public class AvatarPlatformOffset : MonoBehaviour -{ - public bool correctVrPlatformOffsetOnStart = true; - - void Start() - { - if (correctVrPlatformOffsetOnStart) - { - var p = transform.position; - p.y -= PoseManager.Instance.vrSystemOffsetHeight; - transform.position = p; - } - } -} diff --git a/vrarmik/Transform.js b/vrarmik/Unity.js similarity index 100% rename from vrarmik/Transform.js rename to vrarmik/Unity.js From 459d446b286cefc305f98ac08374e7fdf9b56c2b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 22:51:11 -0400 Subject: [PATCH 033/562] Major vrarmik porting work --- vrarmik/ArmTransforms.js | 61 +++--- vrarmik/AvatarVRTrackingReferences.js | 43 ++-- vrarmik/PoseManager.js | 41 ++-- vrarmik/ShoulderPoser.js | 209 +++++++++---------- vrarmik/StaticOffsetTransform.js | 46 ++--- vrarmik/Unity.js | 24 ++- vrarmik/VRArmIK.js | 283 +++++++++++++------------- vrarmik/VRTrackingReferences.js | 20 +- 8 files changed, 381 insertions(+), 346 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 31ffada..5895098 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,3 +1,6 @@ +import Transform from './Transform.js'; +import PoseManager from './PoseManager.js'; + class ArmTransforms { constructor() { @@ -13,80 +16,80 @@ class ArmTransforms } get upperArmLength() { - return distance(upperArm, lowerArm); + return distance(this.upperArm, this.lowerArm); } get lowerArmLength() { - return distance(lowerArm, hand); + return distance(this.lowerArm, this.hand); } get armLength() { - return upperArmLength + lowerArmLength; + return this.upperArmLength + this.lowerArmLength; } - distance(Transform a, Transform b) { + distance(a, b) { return (a.position - b.position).magnitude; } Start() { - PoseManager.Instance.onCalibrate += updateArmLengths; - updateArmLengths(); + PoseManager.Instance.onCalibrate += this.updateArmLengths; + this.updateArmLengths(); } updateArmLengths() { - var shoulderWidth = (upperArm.position - lowerArm.position).magnitude; - var _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2; - setArmLength(_armLength); + const shoulderWidth = (this.upperArm.position - this.lowerArm.position).magnitude; + const _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2; + this.setArmLength(_armLength); } - setUpperArmLength(float length) + setUpperArmLength(length) { if (armLengthByScale) { - float oldLowerArmLength = distance(lowerArm, hand); + const oldLowerArmLength = distance(this.lowerArm, this.hand); - Vector3 newScale = upperArm.localScale - Vector3.Scale(upperArm.localScale, scaleAxis).magnitude * scaleAxis; - float scaleFactor = Vector3.Scale(upperArm.localScale, scaleAxis).magnitude / upperArmLength * length; - newScale += scaleAxis * scaleFactor; - upperArm.localScale = newScale; + let newScale = this.upperArm.localScale - Vector3.Scale(this.upperArm.localScale, this.scaleAxis).magnitude * this.scaleAxis; + const scaleFactor = Vector3.Scale(this.upperArm.localScale, this.scaleAxis).magnitude / upperArmLength * length; + newScale += this.scaleAxis * scaleFactor; + this.upperArm.localScale = newScale; - setLowerArmLength(oldLowerArmLength); + this.setLowerArmLength(oldLowerArmLength); } else { - Vector3 pos = lowerArm.localPosition; + const pos = this.lowerArm.localPosition; pos.x = Mathf.Sign(pos.x) * length; - lowerArm.localPosition = pos; + this.lowerArm.localPosition = pos; } } - setLowerArmLength(float length) + setLowerArmLength(length) { - if (armLengthByScale) + if (this.armLengthByScale) { } else { - Vector3 pos = hand.localPosition; + const pos = this.hand.localPosition; pos.x = Mathf.Sign(pos.x) * length; - hand.localPosition = pos; + this.hand.localPosition = pos; } } - setArmLength(float length) + setArmLength(length) { - float upperArmFactor = .48; + const upperArmFactor = .48; if (armLengthByScale) { - upperArm.localScale = upperArm.localScale / armLength * length; - hand.localScale = Vector3.one / (1 - (1 - scaleHandFactor) * (1 - upperArm.localScale.x)); + this.upperArm.localScale = this.upperArm.localScale / this.armLength * length; + this.hand.localScale = Vector3.one / (1 - (1 - this.scaleHandFactor) * (1 - this.upperArm.localScale.x)); } else { - setUpperArmLength(length * upperArmFactor); - setLowerArmLength(length * (1 - upperArmFactor)); + this.setUpperArmLength(length * upperArmFactor); + this.setLowerArmLength(length * (1 - upperArmFactor)); } } } -export default ArmTransforms; \ No newline at end of file +export default ArmTransforms; diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index b167b5e..1cdba5d 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,3 +1,4 @@ +import StaticOffsetTransform from './StaticOffsetTransform.js'; class AvatarVRTrackingReferences { @@ -10,16 +11,16 @@ Start() { - initTransforms(); + this.initTransforms(); } initTransforms() { - createTransforms(); - connectTransforms(); + this.createTransforms(); + this.connectTransforms(); } - setStaticOffsetSettings(StaticOffsetTransform s) + setStaticOffsetSettings(s) { s.referenceLocalPosition = false; s.referenceLocalRotation = false; @@ -31,19 +32,19 @@ } - createTransform(ref StaticOffsetTransform t, string name) + createTransform(t, name) { - if (t == null) + if (t === null) { t = new GameObject(name).AddComponent(); t.transform.parent = transform; - setStaticOffsetSettings(t); + this.setStaticOffsetSettings(t); } } - createHandTransform(ref Transform t, string name, Transform parent) + createHandTransform(t, name, parent) { - if (t == null) + if (t === null) { t = new GameObject(name).transform; t.transform.localPosition = Vector3.zero; @@ -53,29 +54,29 @@ createTransforms() { - createTransform(ref head, nameof(head)); - createTransform(ref leftHand, nameof(leftHand)); - createTransform(ref rightHand, nameof(rightHand)); - createTransform(ref hmd, nameof(hmd)); + this.createTransform(head, nameof(head)); + this.createTransform(leftHand, nameof(leftHand)); + this.createTransform(rightHand, nameof(rightHand)); + this.createTransform(hmd, nameof(hmd)); } connectTransforms() { - StaticOffsetTransform sot = this.GetOrAddComponent(); + /*StaticOffsetTransform */const sot = this.GetOrAddComponent/**/(); if (sot.reference == null) { sot.reference = transform.parent; } - head.reference = head.reference != null ? head.reference : PoseManager.Instance.vrTransforms.head; - hmd.reference = hmd.reference != null ? hmd.reference : PoseManager.Instance.vrTransforms.hmd; - leftHand.reference = leftHand.reference != null - ? leftHand.reference + this.head.reference = this.head.reference !== null ? this.head.reference : PoseManager.Instance.vrTransforms.head; + this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : PoseManager.Instance.vrTransforms.hmd; + this.leftHand.reference = leftHand.reference !== null + ? this.leftHand.reference : PoseManager.Instance.vrTransforms.leftHand; - rightHand.reference = rightHand.reference != null - ? rightHand.reference + this.rightHand.reference = this.rightHand.reference !== null + ? this.rightHand.reference : PoseManager.Instance.vrTransforms.rightHand; } } -export default AvatarVRTrackingReferences; \ No newline at end of file +export default AvatarVRTrackingReferences; diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index c8c4f64..8a91bfb 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -1,4 +1,5 @@ import VRTrackingReferences from './VRTrackingReferences.js'; +import {XRSettings} from './Unity.js'; class PoseManager { @@ -20,11 +21,11 @@ class PoseManager OnEnable() { - if (Instance == null) + if (PoseManager.Instance === null) { - Instance = this; + PoseManager.Instance = this; } - else if (Instance != null) + else if (PoseManager.Instance !== null) { Debug.LogError("Multiple Instances of PoseManager in Scene"); } @@ -32,12 +33,12 @@ class PoseManager Awake() { - if (loadPlayerSizeOnAwake) + if (this.loadPlayerSizeOnAwake) { - loadPlayerSize(); + this.loadPlayerSize(); } - var device = XRSettings.loadedDeviceName; - vrSystemOffsetHeight = string.IsNullOrEmpty(device) || device == "OpenVR" ? 0 : playerHeightHmd; + const device = XRSettings.loadedDeviceName; + this.vrSystemOffsetHeight = string.IsNullOrEmpty(device) || device == "OpenVR" ? 0 : this.playerHeightHmd; } Start() @@ -47,40 +48,40 @@ class PoseManager OnCalibrate() { - playerHeightHmd = Camera.main.transform.position.y; + this.playerHeightHmd = Camera.main.transform.position.y; } loadPlayerWidthShoulders() { - playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31); + this.playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31); } - savePlayerWidthShoulders(float width) + savePlayerWidthShoulders(width) { PlayerPrefs.SetFloat("VRArmIK_PlayerWidthShoulders", width); } calibrateIK() { - playerWidthWrist = (vrTransforms.leftHand.position - vrTransforms.rightHand.position).magnitude; - playerHeightHmd = vrTransforms.hmd.position.y; - savePlayerSize(playerHeightHmd, playerWidthWrist); + this.playerWidthWrist = (this.vrTransforms.leftHand.position - this.vrTransforms.rightHand.position).magnitude; + this.playerHeightHmd = this.vrTransforms.hmd.position.y; + this.savePlayerSize(this.playerHeightHmd, this.playerWidthWrist); } savePlayerSize(float heightHmd, float widthWrist) { - PlayerPrefs.SetFloat("VRArmIK_PlayerHeightHmd", heightHmd); - PlayerPrefs.SetFloat("VRArmIK_PlayerWidthWrist", widthWrist); - loadPlayerSize(); - onCalibrate?.Invoke(); + PlayerPrefs.SetFloat("VRArmIK_PlayerHeightHmd", this.heightHmd); + PlayerPrefs.SetFloat("VRArmIK_PlayerWidthWrist", this.widthWrist); + this.loadPlayerSize(); + this.onCalibrate && this.onCalibrate.Invoke(); } loadPlayerSize() { - playerHeightHmd = PlayerPrefs.GetFloat("VRArmIK_PlayerHeightHmd", referencePlayerHeightHmd); - playerWidthWrist = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthWrist", referencePlayerWidthWrist); + this.playerHeightHmd = PlayerPrefs.GetFloat("VRArmIK_PlayerHeightHmd", this.referencePlayerHeightHmd); + this.playerWidthWrist = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthWrist", this.referencePlayerWidthWrist); } } PoseManager.Instance = null; -export default PoseManager; \ No newline at end of file +export default PoseManager; diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index e9f7079..6098137 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,5 +1,6 @@ import ShoulderTransforms from './ShoulderTransforms.js'; import VRTrackingReferences from './VRTrackingReferences.js'; +import PoseManager from './PoseManager.js'; class ShoulderPoser { @@ -51,81 +52,81 @@ class ShoulderPoser Start() { - if (vrTrackingReferences == null) - vrTrackingReferences = PoseManager.Instance.vrTransforms; + if (this.vrTrackingReferences === null) + this.vrTrackingReferences = PoseManager.Instance.vrTransforms; - leftShoulderAnkerStartLocalPosition = shoulder.transform.InverseTransformPoint(shoulder.leftShoulderAnchor.position); - rightShoulderAnkerStartLocalPosition = - shoulder.transform.InverseTransformPoint(shoulder.rightShoulderAnchor.position); + this.leftShoulderAnkerStartLocalPosition = this.shoulder.transform.InverseTransformPoint(this.shoulder.leftShoulderAnchor.position); + this.rightShoulderAnkerStartLocalPosition = + this.shoulder.transform.InverseTransformPoint(this.shoulder.rightShoulderAnchor.position); } onCalibrate() { - shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.transform.position - shoulder.leftShoulderAnchor.position) + this.shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.transform.position - this.shoulder.leftShoulderAnchor.position) .magnitude); - shoulder.rightArm.setArmLength((avatarTrackingReferences.rightHand.transform.position - shoulder.rightShoulderAnchor.position) + this.shoulder.rightArm.setArmLength((avatarTrackingReferences.rightHand.transform.position - this.shoulder.rightShoulderAnchor.position) .magnitude); } Update() { - shoulder.transform.rotation = Quaternion.identity; - positionShoulder(); - rotateShoulderUp(); - rotateShoulderRight(); + this.shoulder.transform.rotation = Quaternion.identity; + this.positionShoulder(); + this.rotateShoulderUp(); + this.rotateShoulderRight(); - if (enableDistinctShoulderRotation) + if (this.enableDistinctShoulderRotation) { - rotateLeftShoulder(); - rotateRightShoulder(); + this.rotateLeftShoulder(); + this.rotateRightShoulder(); } - if (enableShoulderDislocation) + if (this.enableShoulderDislocation) { - clampShoulderHandDistance(); + this.clampShoulderHandDistance(); } else { - shoulder.leftArm.transform.localPosition = Vector3.zero; - shoulder.rightArm.transform.localPosition = Vector3.zero; + this.shoulder.leftArm.transform.localPosition = Vector3.zero; + this.shoulder.rightArm.transform.localPosition = Vector3.zero; } - Debug.DrawRay(shoulder.transform.position, shoulder.transform.forward); + Debug.DrawRay(this.shoulder.transform.position, this.shoulder.transform.forward); } rotateLeftShoulder() { - rotateShoulderUp(shoulder.leftShoulder, shoulder.leftArm, avatarTrackingReferences.leftHand.transform, - leftShoulderAnkerStartLocalPosition, 1); + this.rotateShoulderUp(shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand.transform, + this.leftShoulderAnkerStartLocalPosition, 1); } rotateRightShoulder() { - rotateShoulderUp(shoulder.rightShoulder, shoulder.rightArm, avatarTrackingReferences.rightHand.transform, - rightShoulderAnkerStartLocalPosition, -1); + this.rotateShoulderUp(shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand.transform, + this.rightShoulderAnkerStartLocalPosition, -1); } - rotateShoulderUp(Transform shoulderSide, ArmTransforms arm, Transform targetHand, - Vector3 initialShoulderLocalPos, float angleSign) + rotateShoulderUp(shoulderSide, arm, targetHand, + initialShoulderLocalPos, angleSign) { - Vector3 initialShoulderPos = shoulder.transform.TransformPoint(initialShoulderLocalPos); - Vector3 handShoulderOffset = targetHand.position - initialShoulderPos; - float armLength = arm.armLength; + const initialShoulderPos = this.shoulder.transform.TransformPoint(initialShoulderLocalPos); + const handShoulderOffset = targetHand.position - this.initialShoulderPos; + const armLength = arm.armLength; - Vector3 targetAngle = Vector3.zero; + const targetAngle = Vector3.zero; - float forwardDistanceRatio = Vector3.Dot(handShoulderOffset, shoulder.transform.forward) / armLength; - float upwardDistanceRatio = Vector3.Dot(handShoulderOffset, shoulder.transform.up) / armLength; + const forwardDistanceRatio = Vector3.Dot(handShoulderOffset, this.shoulder.transform.forward) / armLength; + const upwardDistanceRatio = Vector3.Dot(handShoulderOffset, this.shoulder.transform.up) / armLength; if (forwardDistanceRatio > 0) { - targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5) * distinctShoulderRotationMultiplier, 0, - distinctShoulderRotationLimitForward); + targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, 0, + this.distinctShoulderRotationLimitForward); } else { - targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08) * distinctShoulderRotationMultiplier * 10, - -distinctShoulderRotationLimitBackward, 0); + targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08) * this.distinctShoulderRotationMultiplier * 10, + -this.distinctShoulderRotationLimitBackward, 0); } targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5) * distinctShoulderRotationMultiplier, @@ -137,153 +138,155 @@ class ShoulderPoser positionShoulder() { - Vector3 headNeckOffset = avatarTrackingReferences.hmd.transform.rotation * headNeckDirectionVector; - Vector3 targetPosition = avatarTrackingReferences.head.transform.position + headNeckOffset * headNeckDistance; - shoulder.transform.localPosition = - shoulder.transform.parent.InverseTransformPoint(targetPosition) + neckShoulderDistance; + const headNeckOffset = this.avatarTrackingReferences.hmd.transform.rotation * this.headNeckDirectionVector; + const targetPosition = this.avatarTrackingReferences.head.transform.position + headNeckOffset * this.headNeckDistance; + this.shoulder.transform.localPosition = + this.shoulder.transform.parent.InverseTransformPoint(targetPosition) + this.neckShoulderDistance; } rotateShoulderUp() { - float angle = getCombinedDirectionAngleUp(); + const angle = getCombinedDirectionAngleUp(); - Vector3 targetRotation = new Vector3(0, angle, 0); + const targetRotation = new Vector3(0, angle, 0); - if (autoDetectHandsBehindHead) + if (this.autoDetectHandsBehindHead) { - detectHandsBehindHead(ref targetRotation); + this.detectHandsBehindHead(targetRotation); } - if (clampRotationToHead) + if (this.clampRotationToHead) { - clampHeadRotationDeltaUp(ref targetRotation); + this.clampHeadRotationDeltaUp(targetRotation); } - shoulder.transform.eulerAngles = targetRotation; + shouldthis.er.transform.eulerAngles = targetRotation; } rotateShoulderRight() { - float heightDiff = vrTrackingReferences.hmd.transform.position.y - PoseManager.Instance.vrSystemOffsetHeight; - float relativeHeightDiff = -heightDiff / PoseManager.Instance.playerHeightHmd; + const heightDiff = this.vrTrackingReferences.hmd.transform.position.y - PoseManager.Instance.vrSystemOffsetHeight; + const relativeHeightDiff = -heightDiff / PoseManager.Instance.playerHeightHmd; - float headRightRotation = VectorHelpers.getAngleBetween(shoulder.transform.forward, - avatarTrackingReferences.hmd.transform.forward, - Vector3.up, shoulder.transform.right) + rightRotationHeadRotationOffset; - float heightFactor = Mathf.Clamp(relativeHeightDiff - rightRotationStartHeight, 0, 1); - shoulderRightRotation = heightFactor * rightRotationHeightFactor; - shoulderRightRotation += Mathf.Clamp(headRightRotation * rightRotationHeadRotationFactor * heightFactor, 0, 50); + const headRightRotation = VectorHelpers.getAngleBetween(this.shoulder.transform.forward, + this.avatarTrackingReferences.hmd.transform.forward, + Vector3.up, this.shoulder.transform.right) + this.rightRotationHeadRotationOffset; + const heightFactor = Mathf.Clamp(relativeHeightDiff - this.rightRotationStartHeight, 0, 1); + this.shoulderRightRotation = heightFactor * this.rightRotationHeightFactor; + this.shoulderRightRotation += Mathf.Clamp(headRightRotation * this.rightRotationHeadRotationFactor * heightFactor, 0, 50); - shoulderRightRotation = Mathf.Clamp(shoulderRightRotation, 0, 50); + this.shoulderRightRotation = Mathf.Clamp(this.shoulderRightRotation, 0, 50); - Quaternion deltaRot = Quaternion.AngleAxis(shoulderRightRotation, shoulder.transform.right); + const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right); - shoulder.transform.rotation = deltaRot * shoulder.transform.rotation; - positionShoulderRelative(); + this.shoulder.transform.rotation = deltaRot * this.shoulder.transform.rotation; + this.positionShoulderRelative(); } positionShoulderRelative() { - Quaternion deltaRot = Quaternion.AngleAxis(shoulderRightRotation, shoulder.transform.right); - Vector3 shoulderHeadDiff = shoulder.transform.position - avatarTrackingReferences.head.transform.position; - shoulder.transform.position = deltaRot * shoulderHeadDiff + avatarTrackingReferences.head.transform.position; + const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right); + const shoulderHeadDiff = this.shoulder.transform.position - this.avatarTrackingReferences.head.transform.position; + this.shoulder.transform.position = deltaRot * shoulderHeadDiff + this.avatarTrackingReferences.head.transform.position; } getCombinedDirectionAngleUp() { - Transform leftHand = avatarTrackingReferences.leftHand.transform, rightHand = avatarTrackingReferences.rightHand.transform; + const leftHand = this.avatarTrackingReferences.leftHand.transform; + const rightHand = this.avatarTrackingReferences.rightHand.transform; - Vector3 distanceLeftHand = leftHand.position - shoulder.transform.position, - distanceRightHand = rightHand.position - shoulder.transform.position; + const distanceLeftHand = leftHand.position - this.shoulder.transform.position; + const distanceRightHand = rightHand.position - this.shoulder.transform.position; - if (ignoreYPos) + if (this.ignoreYPos) { - distanceLeftHand.y = 0; - distanceRightHand.y = 0; + this.distanceLeftHand.y = 0; + this.distanceRightHand.y = 0; } - Vector3 directionLeftHand = distanceLeftHand.normalized, - directionRightHand = distanceRightHand.normalized; + const directionLeftHand = distanceLeftHand.normalized; + const directionRightHand = distanceRightHand.normalized; - Vector3 combinedDirection = directionLeftHand + directionRightHand; + const combinedDirection = directionLeftHand + directionRightHand; return Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180 / Mathf.PI; } - detectHandsBehindHead(ref Vector3 targetRotation) + detectHandsBehindHead(targetRotation) { - float delta = Mathf.Abs(targetRotation.y - lastAngle.y + 360) % 360; - if (delta > 150 && delta < 210 && lastAngle.magnitude > 0.000001 && !clampingHeadRotation) + const delta = Mathf.Abs(targetRotation.y - this.lastAngle.y + 360) % 360; + if (delta > 150 && delta < 210 && this.lastAngle.magnitude > 0.000001 && !clampingHeadRotation) { - handsBehindHead = !handsBehindHead; + this.handsBehindHead = !this.handsBehindHead; } - lastAngle = targetRotation; + this.lastAngle = targetRotation; - if (handsBehindHead) + if (this.handsBehindHead) { targetRotation.y += 180; } } - clampHeadRotationDeltaUp(ref Vector3 targetRotation) + clampHeadRotationDeltaUp(targetRotation) { - float headUpRotation = (avatarTrackingReferences.head.transform.eulerAngles.y + 360) % 360; - float targetUpRotation = (targetRotation.y + 360) % 360; + const headUpRotation = (this.avatarTrackingReferences.head.transform.eulerAngles.y + 360) % 360; + const targetUpRotation = (targetRotation.y + 360) % 360; - float delta = headUpRotation - targetUpRotation; + const delta = headUpRotation - targetUpRotation; - if (delta > maxDeltaHeadRotation && delta < 180 || delta < -180 && delta >= -360 + maxDeltaHeadRotation) + if (delta > this.maxDeltaHeadRotation && delta < 180 || delta < -180 && delta >= -360 + this.maxDeltaHeadRotation) { - targetRotation.y = headUpRotation - maxDeltaHeadRotation; - clampingHeadRotation = true; + targetRotation.y = headUpRotation - this.maxDeltaHeadRotation; + this.clampingHeadRotation = true; } - else if (delta < -maxDeltaHeadRotation && delta > -180 || delta > 180 && delta < 360 - maxDeltaHeadRotation) + else if (delta < -this.maxDeltaHeadRotation && delta > -180 || delta > 180 && delta < 360 - this.maxDeltaHeadRotation) { - targetRotation.y = headUpRotation + maxDeltaHeadRotation; - clampingHeadRotation = true; + targetRotation.y = headUpRotation + this.maxDeltaHeadRotation; + this.clampingHeadRotation = true; } else { - clampingHeadRotation = false; + this.clampingHeadRotation = false; } } clampShoulderHandDistance() { - Vector3 leftHandVector = avatarTrackingReferences.leftHand.transform.position - shoulder.leftShoulderAnchor.position; - Vector3 rightHandVector = avatarTrackingReferences.rightHand.transform.position - shoulder.rightShoulderAnchor.position; - float leftShoulderHandDistance = leftHandVector.magnitude, rightShoulderHandDistance = rightHandVector.magnitude; - shoulderDislocated = false; + const leftHandVector = this.avatarTrackingReferences.leftHand.transform.position - this.shoulder.leftShoulderAnchor.position; + const rightHandVector = this.avatarTrackingReferences.rightHand.transform.position - this.shoulder.rightShoulderAnchor.position; + const leftShoulderHandDistance = leftHandVector.magnitude; + const rightShoulderHandDistance = rightHandVector.magnitude; + this.shoulderDislocated = false; - float startBeforeFactor = (1 - startShoulderDislocationBefore); + const startBeforeFactor = (1 - this.startShoulderDislocationBefore); - if (leftShoulderHandDistance > shoulder.leftArm.armLength * startBeforeFactor) + if (leftShoulderHandDistance > this.shoulder.leftArm.armLength * startBeforeFactor) { - shoulderDislocated = true; - shoulder.leftArm.transform.position = shoulder.leftShoulderAnchor.position + + this.shoulderDislocated = true; + this.shoulder.leftArm.transform.position = this.shoulder.leftShoulderAnchor.position + leftHandVector.normalized * - (leftShoulderHandDistance - shoulder.leftArm.armLength * startBeforeFactor); + (leftShoulderHandDistance - this.shoulder.leftArm.armLength * startBeforeFactor); } else { - shoulder.leftArm.transform.localPosition = Vector3.zero; + this.shoulder.leftArm.transform.localPosition = Vector3.zero; } - if (rightShoulderHandDistance > shoulder.rightArm.armLength * startBeforeFactor) + if (rightShoulderHandDistance > this.shoulder.rightArm.armLength * this.startBeforeFactor) { - shoulderDislocated = true; - shoulder.rightArm.transform.position = shoulder.rightShoulderAnchor.position + + this.shoulderDislocated = true; + this.shoulder.rightArm.transform.position = this.shoulder.rightShoulderAnchor.position + rightHandVector.normalized * (rightShoulderHandDistance - - shoulder.rightArm.armLength * startBeforeFactor); + this.shoulder.rightArm.armLength * startBeforeFactor); } else { - shoulder.rightArm.transform.localPosition = Vector3.zero; + this.shoulder.rightArm.transform.localPosition = Vector3.zero; } } } -export default ShoulderPoser; \ No newline at end of file +export default ShoulderPoser; diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index b6a1b7c..c715032 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -27,7 +27,7 @@ class StaticOffsetTransform this.applyForwardOffsetAfterRotationOffset = false; } - switchAxis(Vector3 r, EulerOrder order) + switchAxis(r, order) { switch (order) { @@ -51,66 +51,66 @@ class StaticOffsetTransform Awake() { - updatePosition(); + this.updatePosition(); } Update() { - updatePosition(); + this.updatePosition(); } updatePosition() { - if (reference == null) + if (this.reference === null) return; - Vector3 rot = switchAxis(referenceLocalRotation ? reference.localEulerAngles : reference.eulerAngles, axisOrder) + - offsetRotation; + const rot = this.switchAxis(this.referenceLocalRotation ? reference.localEulerAngles : reference.eulerAngles, this.axisOrder) + + this.offsetRotation; rot.Scale(referenceRotationMultiplicator); - Vector3 pos = referenceLocalPosition ? reference.localPosition : reference.position; + const pos = this.referenceLocalPosition ? this.reference.localPosition : this.reference.position; - if (applyForwardOffsetAfterRotationOffset) + if (this.applyForwardOffsetAfterRotationOffset) { - pos += Quaternion.Euler(rot) * Vector3.right * orientationalOffset.x; - pos += Quaternion.Euler(rot) * Vector3.up * orientationalOffset.y; - pos += Quaternion.Euler(rot) * Vector3.forward * orientationalOffset.z; + pos += Quaternion.Euler(rot) * Vector3.right * this.orientationalOffset.x; + pos += Quaternion.Euler(rot) * Vector3.up * othis.rientationalOffset.y; + pos += Quaternion.Euler(rot) * Vector3.forward * this.orientationalOffset.z; } else { - pos += reference.right * orientationalOffset.x; - pos += reference.up * orientationalOffset.y; - pos += reference.forward * orientationalOffset.z; + pos += this.reference.right * this.orientationalOffset.x; + pos += this.reference.up * this.orientationalOffset.y; + pos += this.reference.forward * this.orientationalOffset.z; } pos += offsetPosition; - if (applyPosition) + if (this.applyPosition) { - if (applyLocalPosition) + if (this.applyLocalPosition) { - transform.localPosition = pos; + this.transform.localPosition = pos; } else { - transform.position = pos; + this.transform.position = pos; } } - if (applyRotation) + if (this.applyRotation) { - if (applyLocalRotation) + if (this.applyLocalRotation) { - transform.localEulerAngles = rot; + this.transform.localEulerAngles = rot; } else { - transform.eulerAngles = rot; + this.transform.eulerAngles = rot; } } } } -export default StaticOffsetTransform; \ No newline at end of file +export default StaticOffsetTransform; diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 5b74539..ec78eb1 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -6,4 +6,26 @@ class Transform { } } -export default Transform; +const PlayerPrefs = { + data: {}, + GetFloat(k, d) { + let v = this.data[k]; + if (v === undefined) { + v = d; + } + return v; + }, + SetFloat(k, v) { + this.data[k] = v; + }, +}; + +const XRSettings = { + loadedDeviceName: 'OpenVR', +}; + +export { + Transform, + PlayerPrefs, + XRSettings, +}; diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index dde97a0..713981b 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,3 +1,4 @@ +import Transform from './Transform.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; @@ -89,46 +90,46 @@ class HandSettings Awake() { - upperArmStartRotation = arm.upperArm.rotation; - lowerArmStartRotation = arm.lowerArm.rotation; - wristStartRotation = Quaternion.identity; - if (arm.wrist1 != null) - wristStartRotation = arm.wrist1.rotation; - handStartRotation = arm.hand.rotation; + this.upperArmStartRotation = this.arm.upperArm.rotation; + this.lowerArmStartRotation = this.arm.lowerArm.rotation; + this.wristStartRotation = Quaternion.identity; + if (this.arm.wrist1 != null) + wthis.ristStartRotation = arm.wrist1.rotation; + this.handStartRotation = arm.hand.rotation; } OnEnable() { - setUpperArmRotation(Quaternion.identity); - setLowerArmRotation(Quaternion.identity); - setHandRotation(Quaternion.identity); + this.setUpperArmRotation(Quaternion.identity); + this.setLowerArmRotation(Quaternion.identity); + this.setHandRotation(Quaternion.identity); } LateUpdate() { - updateUpperArmPosition(); - calcElbowInnerAngle(); - rotateShoulder(); - correctElbowRotation(); - if (elbowSettings.calcElbowAngle) + this.updateUpperArmPosition(); + this.calcElbowInnerAngle(); + this.rotateShoulder(); + this.correctElbowRotation(); + if (this.elbowSettings.calcElbowAngle) { - positionElbow(); - if (elbowCorrectionSettings.useFixedElbowWhenNearShoulder) - correctElbowAfterPositioning(); - if (handSettings.rotateElbowWithHandRight) - rotateElbowWithHandRight(); - if (handSettings.rotateElbowWithHandForward) - rotateElbowWithHandFoward(); - rotateHand(); + this.positionElbow(); + if (this.elbowCorrectionSettings.useFixedElbowWhenNearShoulder) + this.correctElbowAfterPositioning(); + if (this.handSettings.rotateElbowWithHandRight) + this.rotateElbowWithHandRight(); + if (this.handSettings.rotateElbowWithHandForward) + this.rotateElbowWithHandFoward(); + this.rotateHand(); } } updateArmAndTurnElbowUp() { - updateUpperArmPosition(); - calcElbowInnerAngle(); - rotateShoulder(); - correctElbowRotation(); + this.updateUpperArmPosition(); + this.calcElbowInnerAngle(); + this.rotateShoulder(); + this.correctElbowRotation(); } updateUpperArmPosition() @@ -138,19 +139,19 @@ class HandSettings calcElbowInnerAngle() { - Vector3 eulerAngles = new Vector3(); - float targetShoulderDistance = (target.position - upperArmPos).magnitude; - float innerAngle; + const eulerAngles = new Vector3(); + const targetShoulderDistance = (this.target.position - this.upperArmPos).magnitude; + let innerAngle; - if (targetShoulderDistance > arm.armLength) + if (targetShoulderDistance > this.arm.armLength) { innerAngle = 0; } else { - innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(arm.upperArmLength, 2) + Mathf.Pow(arm.lowerArmLength, 2) - - Mathf.Pow(targetShoulderDistance, 2)) / (2 * arm.upperArmLength * arm.lowerArmLength), -1, 1)) * Mathf.Rad2Deg; - if (left) + innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(this.arm.upperArmLength, 2) + Mathf.Pow(this.arm.lowerArmLength, 2) - + Mathf.Pow(targetShoulderDistance, 2)) / (2 * this.arm.upperArmLength * this.arm.lowerArmLength), -1, 1)) * Mathf.Rad2Deg; + if (this.left) innerAngle = 180 - innerAngle; else innerAngle = 180 + innerAngle; @@ -161,65 +162,65 @@ class HandSettings } eulerAngles.y = innerAngle; - nextLowerArmAngle = eulerAngles; + this.nextLowerArmAngle = eulerAngles; } //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp rotateShoulder() { - Vector3 eulerAngles = new Vector3(); - Vector3 targetShoulderDirection = (target.position - upperArmPos).normalized; - float targetShoulderDistance = (target.position - upperArmPos).magnitude; + const eulerAngles = new Vector3(); + const targetShoulderDirection = (target.position - upperArmPos).normalized; + const targetShoulderDistance = (target.position - upperArmPos).magnitude; - eulerAngles.y = (left ? -1 : 1) * - Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(arm.upperArmLength, 2) - - Mathf.Pow(arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; + eulerAngles.y = (this.left ? -1 : 1) * + Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(this.arm.upperArmLength, 2) - + Mathf.Pow(this.arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * this.arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; if (float.IsNaN(eulerAngles.y)) eulerAngles.y = 0; - Quaternion shoulderRightRotation = Quaternion.FromToRotation(armDirection, targetShoulderDirection); - setUpperArmRotation(shoulderRightRotation); - arm.upperArm.rotation = Quaternion.AngleAxis(eulerAngles.y, lowerArmRotation * Vector3.up) * arm.upperArm.rotation; - setLowerArmLocalRotation(Quaternion.Euler(nextLowerArmAngle)); + const shoulderRightRotation = Quaternion.FromToRotation(this.armDirection, targetShoulderDirection); + this.setUpperArmRotation(shoulderRightRotation); + this.arm.upperArm.rotation = Quaternion.AngleAxis(eulerAngles.y, lowerArmRotation * Vector3.up) * this.arm.upperArm.rotation; + this.setLowerArmLocalRotation(Quaternion.Euler(this.nextLowerArmAngle)); } getElbowTargetAngle() { - Vector3 localHandPosNormalized = shoulderAnker.InverseTransformPoint(handPos) / arm.armLength; + const localHandPosNormalized = this.shoulderAnker.InverseTransformPoint(this.handPos) / this.arm.armLength; // angle from Y - var angle = elbowSettings.yWeight * localHandPosNormalized.y + elbowSettings.offsetAngle; + let angle = this.elbowSettings.yWeight * localHandPosNormalized.y + this.elbowSettings.offsetAngle; // angle from Z /*angle += Mathf.Lerp(elbowSettings.zWeightBottom, elbowSettings.zWeightTop, Mathf.Clamp01((localHandPosNormalized.y + 1f) - elbowSettings.zBorderY)) * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f));*/ if (localHandPosNormalized.y > 0) - angle += elbowSettings.zWeightTop * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(localHandPosNormalized.y, 0)); + angle += this.elbowSettings.zWeightTop * (Mathf.Max(this.elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(localHandPosNormalized.y, 0)); else - angle += elbowSettings.zWeightBottom * (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(-localHandPosNormalized.y, 0)); + angle += this.elbowSettings.zWeightBottom * (Mathf.Max(this.elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(-localHandPosNormalized.y, 0)); // angle from X - angle += elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (left ? 1.0 : -1.0) + elbowSettings.xDistanceStart, 0); + angle += this.elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (this.left ? 1.0 : -1.0) + this.elbowSettings.xDistanceStart, 0); - if (elbowSettings.clampElbowAngle) + if (this.elbowSettings.clampElbowAngle) { - if (elbowSettings.softClampElbowAngle) + if (this.elbowSettings.softClampElbowAngle) { - if (angle < elbowSettings.minAngle + elbowSettings.softClampRange) + if (angle < this.elbowSettings.minAngle + this.elbowSettings.softClampRange) { - float a = elbowSettings.minAngle + elbowSettings.softClampRange - angle; - angle = elbowSettings.minAngle + elbowSettings.softClampRange * (1 - Mathf.Log(1 + a) * 3); + const a = this.elbowSettings.minAngle + this.elbowSettings.softClampRange - angle; + angle = this.elbowSettings.minAngle + this.elbowSettings.softClampRange * (1 - Mathf.Log(1 + a) * 3); } } else { - angle = Mathf.Clamp(angle, elbowSettings.minAngle, elbowSettings.maxAngle); + angle = Mathf.Clamp(angle, this.elbowSettings.minAngle, this.elbowSettings.maxAngle); } } - if (left) + if (this.left) angle *= -1; return angle; @@ -227,27 +228,27 @@ class HandSettings correctElbowRotation() { - var s = beforePositioningSettings; + const s = beforePositioningSettings; - Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; - float elbowOutsideFactor = Mathf.Clamp01( + const localTargetPos = this.shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; + const elbowOutsideFactor = Mathf.Clamp01( Mathf.Clamp01((s.startBelowZ - localTargetPos.z) / Mathf.Abs(s.startBelowZ) * .5) * Mathf.Clamp01((localTargetPos.y - s.startAboveY) / Mathf.Abs(s.startAboveY)) * - Mathf.Clamp01(1 - localTargetPos.x * (left ? -1 : 1)) + Mathf.Clamp01(1 - localTargetPos.x * (this.left ? -1 : 1)) ) * s.weight; - Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; - Vector3 targetDir = shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (armDirection + Vector3.forward * -.2) * elbowOutsideFactor : Vector3.zero)); - Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000); + const shoulderHandDirection = (this.upperArmPos - this.handPos).normalized; + const targetDir = this.shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (this.armDirection + Vector3.forward * -.2) * elbowOutsideFactor : Vector3.zero)); + const cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000); - Vector3 upperArmUp = upperArmRotation * Vector3.up; + const upperArmUp = upperArmRotation * Vector3.up; - float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - float elbowAngle = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); - Quaternion rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); - arm.upperArm.rotation = rotation * arm.upperArm.rotation; + const elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); + const elbowAngle = Vector3.Angle(cross, upperArmUp) + (this.left ? 0 : 180); + const rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); + this.arm.upperArm.rotation = rotation * this.arm.upperArm.rotation; } /// @@ -255,81 +256,81 @@ class HandSettings /// correctElbowAfterPositioning() { - var s = elbowCorrectionSettings; - Vector3 localTargetPos = shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; - Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; - Vector3 elbowPos = s.localElbowPos; + const s = this.elbowCorrectionSettings; + const localTargetPos = this.shoulderAnker.InverseTransformPoint(this.target.position) / this.arm.armLength; + const shoulderHandDirection = (this.upperArmPos - this.handPos).normalized; + const elbowPos = s.localElbowPos; - if (left) + if (this.left) elbowPos.x *= -1; - Vector3 targetDir = shoulder.transform.rotation * elbowPos.normalized; - Vector3 cross = Vector3.Cross(shoulderHandDirection, targetDir); + const targetDir = this.shoulder.transform.rotation * elbowPos.normalized; + const cross = Vector3.Cross(shoulderHandDirection, targetDir); - Vector3 upperArmUp = upperArmRotation * Vector3.up; + const upperArmUp = this.upperArmRotation * Vector3.up; - Vector3 distance = target.position - upperArmPos; - distance = distance.magnitude * shoulder.transform.InverseTransformDirection(distance / distance.magnitude); + let distance = this.target.position - this.upperArmPos; + distance = distance.magnitude * this.shoulder.transform.InverseTransformDirection(distance / distance.magnitude); - float weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / arm.armLength) / + const weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / arm.armLength) / s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1) * 3)) * Mathf.Clamp01((s.startBelowY - localTargetPos.y) / s.startBelowY); - float elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - float elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (left ? 0 : 180); - Quaternion rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); - arm.upperArm.rotation = rotation * arm.upperArm.rotation; + const elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); + const elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (this.left ? 0 : 180); + const rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); + this.arm.upperArm.rotation = rotation * this.arm.upperArm.rotation; } - rotateElbow(float angle) + rotateElbow(angle) { - Vector3 shoulderHandDirection = (upperArmPos - handPos).normalized; + const shoulderHandDirection = (this.upperArmPos - this.handPos).normalized; - Quaternion rotation = Quaternion.AngleAxis(angle, shoulderHandDirection); - setUpperArmRotation(rotation * upperArmRotation); + const rotation = Quaternion.AngleAxis(angle, shoulderHandDirection); + this.setUpperArmRotation(rotation * this.upperArmRotation); } //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp positionElbow() { - float targetElbowAngle = getElbowTargetAngle(); - rotateElbow(targetElbowAngle); + const targetElbowAngle = this.getElbowTargetAngle(); + this.rotateElbow(targetElbowAngle); } rotateElbowWithHandRight() { - var s = handSettings; - Vector3 handUpVec = target.rotation * Vector3.up; - float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, + const s = this.handSettings; + let handUpVec = this.target.rotation * Vector3.up; + const forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, this.target.rotation * Vector3.right, lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); // todo reduce influence if hand local forward rotation is high (hand tilted inside) - Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); + const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); handUpVec = handForwardRotation * handUpVec; - float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, - lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); + const elbowTargetAngle = VectorHelpers.getAngleBetween(this.lowerArmRotation * Vector3.up, handUpVec, + this.lowerArmRotation * Vector3.forward, this.lowerArmRotation * this.armDirection); - float deltaElbow = (elbowTargetAngle + (left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180; + let deltaElbow = (elbowTargetAngle + (this.left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180; deltaElbow = Mathf.Sign(deltaElbow) * Mathf.Pow(Mathf.Abs(deltaElbow), s.handDeltaPow) * 180 * s.handDeltaFactor; - interpolatedDeltaElbow = - Mathf.LerpAngle(interpolatedDeltaElbow, deltaElbow, Time.deltaTime / s.rotateElbowWithHandDelay); - rotateElbow(interpolatedDeltaElbow); + this.interpolatedDeltaElbow = + Mathf.LerpAngle(this.interpolatedDeltaElbow, deltaElbow, Time.deltaTime / s.rotateElbowWithHandDelay); + this.rotateElbow(this.interpolatedDeltaElbow); } rotateElbowWithHandFoward() { - var s = handSettings; - Vector3 handRightVec = target.rotation * armDirection; + const s = this.handSettings; + const handRightVec = this.target.rotation * this.armDirection; - float elbowTargetAngleForward = VectorHelpers.getAngleBetween(lowerArmRotation * armDirection, handRightVec, - lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + const elbowTargetAngleForward = VectorHelpers.getAngleBetween(this.lowerArmRotation * armDirection, handRightVec, + this.lowerArmRotation * Vector3.up, this.lowerArmRotation * Vector3.forward); - float deltaElbowForward = (elbowTargetAngleForward + (left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180; + let deltaElbowForward = (elbowTargetAngleForward + (this.left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180; if (Mathf.Abs(deltaElbowForward) < s.handDeltaForwardDeadzone) deltaElbowForward = 0; @@ -339,86 +340,86 @@ class HandSettings } deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180; - interpolatedDeltaElbowForward = Mathf.LerpAngle(interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); + this.interpolatedDeltaElbowForward = Mathf.LerpAngle(this.interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); - float signedInterpolated = interpolatedDeltaElbowForward.toSignedEulerAngle(); - rotateElbow(signedInterpolated * s.handDeltaForwardFactor); + const signedInterpolated = this.interpolatedDeltaElbowForward.toSignedEulerAngle(); + this.rotateElbow(signedInterpolated * s.handDeltaForwardFactor); } rotateHand() { - if (handSettings.useWristRotation) + if (this.handSettings.useWristRotation) { - Vector3 handUpVec = target.rotation * Vector3.up; - float forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, target.rotation * Vector3.right, - lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + let handUpVec = this.target.rotation * Vector3.up; + const forwardAngle = VectorHelpers.getAngleBetween(this.lowerArmRotation * Vector3.right, target.rotation * Vector3.right, + this.lowerArmRotation * Vector3.up, this.lowerArmRotation * Vector3.forward); // todo reduce influence if hand local forward rotation is high (hand tilted inside) - Quaternion handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); + const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, this.lowerArmRotation * Vector3.forward); handUpVec = handForwardRotation * handUpVec; - float elbowTargetAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.up, handUpVec, - lowerArmRotation * Vector3.forward, lowerArmRotation * armDirection); + let elbowTargetAngle = VectorHelpers.getAngleBetween(this.lowerArmRotation * Vector3.up, handUpVec, + this.lowerArmRotation * Vector3.forward, this.lowerArmRotation * this.armDirection); elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90, 90); if (arm.wrist1 != null) - setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3, lowerArmRotation * armDirection) * lowerArmRotation); + this.setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3, this.lowerArmRotation * this.armDirection) * this.lowerArmRotation); if (arm.wrist2 != null) - setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8, lowerArmRotation * armDirection) * lowerArmRotation); + this.setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8, this.lowerArmRotation * this.armDirection) * this.lowerArmRotation); } - setHandRotation(target.rotation); + this.setHandRotation(target.rotation); } - removeShoulderRightRotation(Vector3 direction) { - return Quaternion.AngleAxis(-shoulderPoser.shoulderRightRotation, shoulder.transform.right) * direction; + removeShoulderRightRotation(direction) { + return Quaternion.AngleAxis(-this.shoulderPoser.shoulderRightRotation, this.shoulder.transform.right) * this.direction; } get armDirection() { - return left ? Vector3.left : Vector3.right; + return this.left ? Vector3.left : Vector3.right; } get upperArmPos() { - return arm.upperArm.position; + return this.arm.upperArm.position; } get lowerArmPos() { - return arm.lowerArm.position; + return this.arm.lowerArm.position; } get handPos() { - return arm.hand.position; + return this.arm.hand.position; } get shoulderAnker() { - return left ? shoulder.leftShoulderAnchor : shoulder.rightShoulderAnchor; + return this.left ? this.shoulder.leftShoulderAnchor : this.shoulder.rightShoulderAnchor; } get upperArmRotation() { - return arm.upperArm.rotation * Quaternion.Inverse(upperArmStartRotation); + return this.arm.upperArm.rotation * Quaternion.Inverse(this.upperArmStartRotation); } get lowerArmRotation() { - return arm.lowerArm.rotation * Quaternion.Inverse(lowerArmStartRotation); + return this.arm.lowerArm.rotation * Quaternion.Inverse(this.lowerArmStartRotation); } get handRotation() { - return arm.hand.rotation * Quaternion.Inverse(handStartRotation); + return this.arm.hand.rotation * Quaternion.Inverse(this.handStartRotation); } - setUpperArmRotation(Quaternion rotation) { - return arm.upperArm.rotation = rotation * upperArmStartRotation; + setUpperArmRotation(rotation) { + return this.arm.upperArm.rotation = rotation * this.upperArmStartRotation; } - setLowerArmRotation(Quaternion rotation) { - return arm.lowerArm.rotation = rotation * lowerArmStartRotation; + setLowerArmRotation(rotation) { + return this.arm.lowerArm.rotation = rotation * this.lowerArmStartRotation; } - setLowerArmLocalRotation(Quaternion rotation) { - return arm.lowerArm.rotation = upperArmRotation * rotation * lowerArmStartRotation; + setLowerArmLocalRotation(rotation) { + return this.arm.lowerArm.rotation = this.upperArmRotation * rotation * this.lowerArmStartRotation; } - setWrist1Rotation(Quaternion rotation) { - return arm.wrist1.rotation = rotation * wristStartRotation; + setWrist1Rotation(rotation) { + return this.arm.wrist1.rotation = rotation * this.wristStartRotation; } - setWrist2Rotation(Quaternion rotation) { - return arm.wrist2.rotation = rotation * wristStartRotation; + setWrist2Rotation(rotation) { + return this.arm.wrist2.rotation = rotation * this.wristStartRotation; } - setWristLocalRotation(Quaternion rotation) { - return arm.wrist1.rotation = arm.lowerArm.rotation * rotation * wristStartRotation; + setWristLocalRotation(rotation) { + return this.arm.wrist1.rotation = this.arm.lowerArm.rotation * rotation * this.wristStartRotation; } - setHandRotation(Quaternion rotation) { - return arm.hand.rotation = arm.hand.rotation = rotation * handStartRotation; + setHandRotation(rotation) { + return this.arm.hand.rotation = this.arm.hand.rotation = rotation * this.handStartRotation; } } diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index 861c2e2..3b0b0ac 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -1,11 +1,15 @@ - class VRTrackingReferences +import Transform from './Transform.js'; + + class VRTrackingReferences { - this.leftController = new Transform(); - this.rightController = new Transform(); - this.hmd = new Transform(); - this.leftHand = new Transform(); - this.rightHand = new Transform(); - this.head = new Transform(); + constructor() { + this.leftController = new Transform(); + this.rightController = new Transform(); + this.hmd = new Transform(); + this.leftHand = new Transform(); + this.rightHand = new Transform(); + this.head = new Transform(); + } } -export default VRTrackingReferences; \ No newline at end of file +export default VRTrackingReferences; From 90b13d7e061b14352f1ef86404c5a3dd0a3d8f59 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:30:37 -0400 Subject: [PATCH 034/562] Bugfix euler order --- vrarmik/StaticOffsetTransform.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index c715032..5dae7d1 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -16,7 +16,7 @@ class StaticOffsetTransform this.orientationalOffset = new Vector3(); this.referenceRotationMultiplicator = Vector3.one; - this.axisOrder = new EulerOrder(); + this.axisOrder = EulerOrder.XYZ; this.referenceLocalPosition = false; this.referenceLocalRotation = false; From 62d10cc9e1c8ec8d1e316e8d61b59ba8b02d55bc Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:31:58 -0400 Subject: [PATCH 035/562] More unity compatibility debugging --- vrarmik/StaticOffsetTransform.js | 2 ++ vrarmik/Unity.js | 57 ++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+) diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index 5dae7d1..16d2eeb 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -1,3 +1,5 @@ +import {Vector3} from './Unity.js'; + const EulerOrder = { XYZ: 'XYZ', XZY: 'XZY', diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index ec78eb1..4f58df8 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -1,9 +1,66 @@ +const DEG2RAD = Math.PI/180; +const RAD2DEG = 180/Math.PI; + +class Vector3 extends THREE.Vector3 { + static get zero() { + return new Vector3(0, 0, 0); + } + static get one() { + return new Vector3(1, 1, 1); + } + static get right() { + return new Vector3(1, 0, 0); + } + static get up() { + return new Vector3(0, 1, 0); + } + static get forward() { + return new Vector3(0, 0, 1); + } + + get normalized() { + return this.clone().normalize(); + } + Dot(v) { + return this.dot(v); + } + Cross(v) { + return this.clone().cross(v); + } + Angle(v) { + return this.angleTo(v) * RAD2DEG; + } +} + +class Quaternion extends THREE.Quaternion() { + static get identity() { + return new Quaternion(0, 0, 0, 1); + } + static AngleAxis(angle, axis) { + return new Quaternion().setFromAxisAngle(axis, angle * DEG2RAD); + } + static FromToRotation(a, b) { + return new Quaternion().setFromUnitVectors(a, b); + } + static Euler(v) { + return new Quaternion().setFromEuler(new Euler(v.x, v.y, v.z, 'ZXY')); + } + + Inverse() { + return this.clone().inverse(); + } +} + class Transform { constructor() { this.position = new Vector3(); this.rotation = new Quaternion(); this.scale = new Vector3(1, 1, 1); } + get eulerAngles() { + const e = new THREE.Euler().setFromQuaternion(this.rotation, 'ZXY'); + return new Vector3(e.x, e.y, e.z); + } } const PlayerPrefs = { From 0a5a1ebdfcbd6f524c25a62e4c68f42cf99ba107 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:47:33 -0400 Subject: [PATCH 036/562] Bugfix unity exposures --- vrarmik/Unity.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 4f58df8..469e43e 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -82,6 +82,8 @@ const XRSettings = { }; export { + Vector3, + Quaternion, Transform, PlayerPrefs, XRSettings, From c75ebdf1c373819ccbf005bd7d3f33d232ef2e50 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:47:50 -0400 Subject: [PATCH 037/562] Add Unity math library --- vrarmik/Unity.js | 60 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 469e43e..ff84444 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -63,6 +63,65 @@ class Transform { } } +const Mathf = { + Deg2Rad: DEG2RAD, + Rad2Deg: RAD2DEG, + PI: Math.PI, + Clamp(v, min, max) { + return Math.min(Math.max(v, min), max); + }, + Clamp01(v) { + return Mathf.Clamp(v, 0, 1); + }, + Min(a, b) { + return Math.min(a, b); + }, + Max(a, b) { + return Math.max(a, b); + }, + Abs(v) { + return Math.abs(v); + }, + Lerp(a, b, t) { + return a*(1-v) + b*v; + }, + LerpAngle(a, b, t) { + const num = Mathf.Repeat(b - a, 360); + if (num > 180) { + num -= 360; + } + return a + num * Mathf.Clamp01(t); + }, + Floor(v) { + return Math.floor(v); + }, + Ceil(v) { + return Math.ceil(v); + }, + Repeat(t, length) { + return t - Mathf.Floor(t / length) * length; + }, + DeltaAngle(current, target) { + let num = Mathf.Repeat(target - current, 360); + if (num > 180) { + num -= 360; + } + return num; + }, + Acos(v) { + return Math.acos(v); + }, + Atan2(a, b) { + return Math.atan2(a, b); + }, + Sign(v) { + return v >= 0 ? 1 : -1; + }, + Pow(a, b) { + return Math.pow(a, b); + }, +}; + const PlayerPrefs = { data: {}, GetFloat(k, d) { @@ -85,6 +144,7 @@ export { Vector3, Quaternion, Transform, + Mathf, PlayerPrefs, XRSettings, }; From 45a4391579c86788014690757ea2186e5b6a6321 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:49:24 -0400 Subject: [PATCH 038/562] Add missing Vector3.Scale --- vrarmik/Unity.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index ff84444..79dca26 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -21,6 +21,9 @@ class Vector3 extends THREE.Vector3 { get normalized() { return this.clone().normalize(); } + Scale(a, b) { + return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z); + } Dot(v) { return this.dot(v); } From 760b63bc6ec387920e9dd88cb97c91a1e09876c4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:51:14 -0400 Subject: [PATCH 039/562] Port VectorHelpers --- vrarmik/Utils/VectorHelpers.js | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/vrarmik/Utils/VectorHelpers.js b/vrarmik/Utils/VectorHelpers.js index dfb63a9..d321590 100644 --- a/vrarmik/Utils/VectorHelpers.js +++ b/vrarmik/Utils/VectorHelpers.js @@ -1,17 +1,19 @@ +import {Vector3, Mathf} from '../Unity.js'; + const VectorHelpers = { - axisAngle(Vector3 v, Vector3 forward, Vector3 axis) + axisAngle(v, forward, axis) { - Vector3 right = Vector3.Cross(axis, forward); + const right = Vector3.Cross(axis, forward); forward = Vector3.Cross(right, axis); return Mathf.Atan2(Vector3.Dot(v, right), Vector3.Dot(v, forward)) * Mathf.Rad2Deg; }, - getAngleBetween(Vector3 a, Vector3 b, Vector3 forward, Vector3 axis) + getAngleBetween(a, b, forward, axis) { - float angleA = axisAngle(a, forward, axis); - float angleB = axisAngle(b, forward, axis); + const angleA = this.axisAngle(a, forward, axis); + const angleB = this.axisAngle(b, forward, axis); return Mathf.DeltaAngle(angleA, angleB); }, }; -export default VectorHelpers; \ No newline at end of file +export default VectorHelpers; From e23529b7150c1cd8e0d659532061c97d19a21338 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:57:23 -0400 Subject: [PATCH 040/562] More unity functions work --- vrarmik/ArmTransforms.js | 2 +- vrarmik/AvatarVRTrackingReferences.js | 2 ++ vrarmik/ShoulderPoser.js | 1 + vrarmik/ShoulderTransforms.js | 3 ++- vrarmik/StaticOffsetTransform.js | 2 +- vrarmik/Unity.js | 3 +++ vrarmik/VRArmIK.js | 2 +- 7 files changed, 11 insertions(+), 4 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 5895098..e3fbebc 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,4 +1,4 @@ -import Transform from './Transform.js'; +import {Vector3, Transform} from './Unity.js'; import PoseManager from './PoseManager.js'; class ArmTransforms diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 1cdba5d..fee3ef6 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,3 +1,5 @@ +import {Vector3} from './Unity.js'; + import StaticOffsetTransform from './StaticOffsetTransform.js'; class AvatarVRTrackingReferences diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 6098137..a3a6cdf 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,3 +1,4 @@ +import {Vector3, Quaternion} from './Unity.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import VRTrackingReferences from './VRTrackingReferences.js'; import PoseManager from './PoseManager.js'; diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index d9b4be0..bdaa9fe 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -1,3 +1,4 @@ +import {Vector3, Transform} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; class ShoulderTransforms @@ -53,4 +54,4 @@ class ShoulderTransforms } } -export default ShoulderTransforms; \ No newline at end of file +export default ShoulderTransforms; diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index 16d2eeb..369a414 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -1,4 +1,4 @@ -import {Vector3} from './Unity.js'; +import {Vector3, Quaternion} from './Unity.js'; const EulerOrder = { XYZ: 'XYZ', diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 79dca26..a641680 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -18,6 +18,9 @@ class Vector3 extends THREE.Vector3 { return new Vector3(0, 0, 1); } + get magnitude() { + return this.length(); + } get normalized() { return this.clone().normalize(); } diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 713981b..b267557 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,4 +1,4 @@ -import Transform from './Transform.js'; +import {Vector3, Quaternion, Transform} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; From a3679ed3716406e1638913e4109fc7b4a61f2343 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 11 Oct 2019 23:59:44 -0400 Subject: [PATCH 041/562] Add more unity transform methods --- vrarmik/Unity.js | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index a641680..4e61753 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -67,6 +67,14 @@ class Transform { const e = new THREE.Euler().setFromQuaternion(this.rotation, 'ZXY'); return new Vector3(e.x, e.y, e.z); } + TransformPoint(v) { + return v.applyMatrix4(new THREE.Matrix4().compose(this.position, this.rotation, this.scale)); + } + InverseTransformPoint(v) { + const m = new THREE.Matrix4().compose(this.position, this.rotation, this.scale); + m.getInverse(m); + return v.applyMatrix4(m); + } } const Mathf = { From bbe6d865035043fca85ebc18c706c444ad9a1247 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 12 Oct 2019 00:00:29 -0400 Subject: [PATCH 042/562] More unity debugging --- vrarmik/VRTrackingReferences.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index 3b0b0ac..6f57b90 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -1,4 +1,4 @@ -import Transform from './Transform.js'; +import {Transform} from './Unity.js'; class VRTrackingReferences { From 8c32c66c32c231b468024dfe34785eeb8bc8611b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 12 Oct 2019 00:04:06 -0400 Subject: [PATCH 043/562] Bugfix isNaN calls --- vrarmik/VRArmIK.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index b267557..57bb636 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -155,7 +155,7 @@ class HandSettings innerAngle = 180 - innerAngle; else innerAngle = 180 + innerAngle; - if (float.IsNaN(innerAngle)) + if (isNaN(innerAngle)) { innerAngle = 180; } @@ -175,7 +175,7 @@ class HandSettings eulerAngles.y = (this.left ? -1 : 1) * Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(this.arm.upperArmLength, 2) - Mathf.Pow(this.arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * this.arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; - if (float.IsNaN(eulerAngles.y)) + if (isNaN(eulerAngles.y)) eulerAngles.y = 0; From 405bc17b38c05343a207a890eca386a2e9783d63 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 12 Oct 2019 00:04:14 -0400 Subject: [PATCH 044/562] Bugfix float references --- vrarmik/PoseManager.js | 2 +- vrarmik/ShoulderTransforms.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 8a91bfb..0a41f34 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -68,7 +68,7 @@ class PoseManager this.savePlayerSize(this.playerHeightHmd, this.playerWidthWrist); } - savePlayerSize(float heightHmd, float widthWrist) + savePlayerSize(heightHmd, widthWrist) { PlayerPrefs.SetFloat("VRArmIK_PlayerHeightHmd", this.heightHmd); PlayerPrefs.SetFloat("VRArmIK_PlayerWidthWrist", this.widthWrist); diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index bdaa9fe..dfe8e75 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -41,7 +41,7 @@ class ShoulderTransforms setShoulderWidth(PoseManager.Instance.playerWidthShoulders); } - setShoulderWidth(float width) + setShoulderWidth(width) { Vector3 localScale = new Vector3(width * .5, .05, .05); Vector3 localPosition = new Vector3(width * .25, 0, 0); From 9eb580d892818c51978e4656f2907757069f0051 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:38:20 -0400 Subject: [PATCH 045/562] Comment out dead method --- vrarmik/AvatarVRTrackingReferences.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index fee3ef6..2d63344 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -44,7 +44,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; } } - createHandTransform(t, name, parent) + /* createHandTransform(t, name, parent) { if (t === null) { @@ -52,7 +52,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; t.transform.localPosition = Vector3.zero; t.transform.parent = parent; } - } + } */ createTransforms() { From 32ae3603ccd2e85109c78d56d78ddc4bf200e4a8 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:39:06 -0400 Subject: [PATCH 046/562] More dead code cleanup --- vrarmik/AvatarVRTrackingReferences.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 2d63344..3895c2e 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -64,11 +64,11 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; connectTransforms() { - /*StaticOffsetTransform */const sot = this.GetOrAddComponent/**/(); - if (sot.reference == null) + /* const sot = this.GetOrAddComponent(StaticOffsetTransform); + if (sot.reference === null) { sot.reference = transform.parent; - } + } */ this.head.reference = this.head.reference !== null ? this.head.reference : PoseManager.Instance.vrTransforms.head; this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : PoseManager.Instance.vrTransforms.hmd; From 87e41d1fdb7e36a17fac6c0f6731987e62c309d9 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:39:29 -0400 Subject: [PATCH 047/562] Syntax cleanup --- vrarmik/ShoulderTransforms.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index dfe8e75..7ca5c25 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -43,8 +43,8 @@ class ShoulderTransforms setShoulderWidth(width) { - Vector3 localScale = new Vector3(width * .5, .05, .05); - Vector3 localPosition = new Vector3(width * .25, 0, 0); + const localScale = new Vector3(width * .5, .05, .05); + const localPosition = new Vector3(width * .25, 0, 0); leftShoulderRenderer.localScale = localScale; leftShoulderRenderer.localPosition = -localPosition; From 86357305f405bf7e48f2ded13124368f36408570 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:40:11 -0400 Subject: [PATCH 048/562] Major Unity transform work --- vrarmik/Unity.js | 172 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 167 insertions(+), 5 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 4e61753..9e21f2b 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -2,6 +2,46 @@ const DEG2RAD = Math.PI/180; const RAD2DEG = 180/Math.PI; class Vector3 extends THREE.Vector3 { + set(x, y, z) { + super.set(x, y, z); + this.onchange && this.onchange(); + } + copy(p) { + super.copy(p); + this.onchange && this.onchange(); + } + + bindOnchange(onchange) { + let x = this.x, y = this.y, z = this.z; + Object.defineProperty(this, 'x', { + get() { + return x; + }, + set(newX) { + x = newX; + onchange(); + }, + }); + Object.defineProperty(this, 'y', { + get() { + return y; + }, + set(newY) { + y = newY; + onchange(); + }, + }); + Object.defineProperty(this, 'z', { + get() { + return z; + }, + set(newZ) { + z = newZ; + onchange(); + }, + }); + } + static get zero() { return new Vector3(0, 0, 0); } @@ -17,7 +57,6 @@ class Vector3 extends THREE.Vector3 { static get forward() { return new Vector3(0, 0, 1); } - get magnitude() { return this.length(); } @@ -38,7 +77,56 @@ class Vector3 extends THREE.Vector3 { } } -class Quaternion extends THREE.Quaternion() { +class Quaternion extends THREE.Quaternion { + set(x, y, z, w) { + super.set(x, y, z, w); + this.onchange && this.onchange(); + } + copy(p) { + super.copy(p); + this.onchange && this.onchange(); + } + + bindOnchange(onchange) { + let x = this.x, y = this.y, z = this.z, w = this.w; + Object.defineProperty(this, 'x', { + get() { + return x; + }, + set(newX) { + x = newX; + onchange(); + }, + }); + Object.defineProperty(this, 'y', { + get() { + return y; + }, + set(newY) { + y = newY; + onchange(); + }, + }); + Object.defineProperty(this, 'z', { + get() { + return z; + }, + set(newZ) { + z = newZ; + onchange(); + }, + }); + Object.defineProperty(this, 'w', { + get() { + return w; + }, + set(newW) { + w = newW; + onchange(); + }, + }); + } + static get identity() { return new Quaternion(0, 0, 0, 1); } @@ -59,10 +147,84 @@ class Quaternion extends THREE.Quaternion() { class Transform { constructor() { - this.position = new Vector3(); - this.rotation = new Quaternion(); - this.scale = new Vector3(1, 1, 1); + this._position = new Vector3(); + this._rotation = new Quaternion(); + this._scale = new Vector3(1, 1, 1); + + this._localPosition = new Vector3(); + const localChange = this.localChange.bind(this); + this._localPosition.bindOnchange(localChange); + this._localRotation = new Quaternion(); + this._localRotation.bindOnchange(localChange); + this._localScale = new Vector3(1, 1, 1); + this._localScale.bindOnchange(localChange); + + this._parent = null; + + this._matrix = new THREE,Matrix4(); + this._matrixWorld = new THREE,Matrix4(); + } + + get position() { + this.updateMatrixWorld(); + return this._position; + } + set position(position) { + this._position.copy(position); + } + get rotation() { + this.updateMatrixWorld(); + return this._rotation; } + set rotation(rotation) { + this._rotation.copy(rotation); + } + get scale() { + this.updateMatrixWorld(); + return this._scale; + } + set scale(scale) { + this._scale.copy(scale); + } + + get localPosition() { + return this._localPosition; + } + set localPosition(localPosition) { + this._localPosition.copy(localPosition); + } + get localRotation() { + return this._localRotation; + } + set localRotation(localRotation) { + this._localRotation.copy(localRotation); + } + get localScale() { + return this._localScale; + } + set localScale(localScale) { + this._localScale.copy(localScale); + } + + updateMatrixWorld() { + if (this.matrixWorldNeedsUpdate) { + this._matrix.compose(this._position, this._rotation, this._scale); + this._matrixWorld.copy(this._matrix); + + if (t.parent) { + t.parent.updateMatrixWorld(); + this._matrixWorld.premultiply(t.parent._matrixWorld); + } + + this._matrixWorld.decompose(this._position, this._rotation, this._scale); + + this.matrixWorldNeedsUpdate = false; + } + } + localChange() { + this.matrixWorldNeedsUpdate = true; + } + get eulerAngles() { const e = new THREE.Euler().setFromQuaternion(this.rotation, 'ZXY'); return new Vector3(e.x, e.y, e.z); From b217cefe7ee00ab7cacdefe72532b937c1d8847b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:40:57 -0400 Subject: [PATCH 049/562] Add Unity MonoBehavior --- vrarmik/Unity.js | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 9e21f2b..6436ac0 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -239,6 +239,28 @@ class Transform { } } +class MonoBehavior { + constructor(transform = new Transform()) { + this.transform = transform; + this.components = new Map(); + } + + GetComponent(Constructor) { + let component = this.components.get(Constructor); + if (component === undefined) { + component = new Constructor(this.transform); + this.components.set(Constructor, component); + } + return component; + } + GetOrAddComponent(Constructor) { + return this.GetComponent(Constructor); + } + GetComponentInChildren(Constructor) { + return this.GetComponent(Constructor); + } +} + const Mathf = { Deg2Rad: DEG2RAD, Rad2Deg: RAD2DEG, @@ -320,6 +342,7 @@ export { Vector3, Quaternion, Transform, + MonoBehavior, Mathf, PlayerPrefs, XRSettings, From 866b48ac1c50f09a6a00eb7ce3d7c1aa3777f7eb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:41:14 -0400 Subject: [PATCH 050/562] Add Unity GameObject --- vrarmik/Unity.js | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 6436ac0..a33948b 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -239,6 +239,17 @@ class Transform { } } +class GameObject { + constructor(name) { + this.name = name; + this.transform = new Transform(); + } + + AddComponent(Constructor) { + return new Constructor(this.transform); + } +} + class MonoBehavior { constructor(transform = new Transform()) { this.transform = transform; @@ -342,6 +353,7 @@ export { Vector3, Quaternion, Transform, + GameObject, MonoBehavior, Mathf, PlayerPrefs, From cb54547fe848cf88535c1d3310a4e826b39a1afd Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:42:17 -0400 Subject: [PATCH 051/562] Major unity emulation debugging --- vrarmik/ArmTransforms.js | 8 ++++--- vrarmik/AvatarVRTrackingReferences.js | 30 +++++++++++++----------- vrarmik/ShoulderTransforms.js | 33 +++++++++++++++------------ vrarmik/StaticOffsetTransform.js | 8 ++++--- vrarmik/VRArmIK.js | 14 +++++++----- 5 files changed, 54 insertions(+), 39 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index e3fbebc..03ae8c9 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,9 +1,11 @@ -import {Vector3, Transform} from './Unity.js'; +import {Vector3, Transform, MonoBehavior} from './Unity.js'; import PoseManager from './PoseManager.js'; -class ArmTransforms +class ArmTransforms extends MonoBehavior { - constructor() { + constructor(transform) { + super(transform); + this.upperArm = new Transform(); this.lowerArm = new Transform(); this.wrist1 = new Transform(); diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 3895c2e..6092960 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,14 +1,16 @@ -import {Vector3} from './Unity.js'; +import {Vector3, GameObject, MonoBehaviour} from './Unity.js'; import StaticOffsetTransform from './StaticOffsetTransform.js'; - class AvatarVRTrackingReferences + class AvatarVRTrackingReferences extends MonoBehaviour { - constructor() { - this.head = new StaticOffsetTransform(); - this.hmd = new StaticOffsetTransform(); - this.leftHand = new StaticOffsetTransform(); - this.rightHand = new StaticOffsetTransform(); + constructor(transform) { + super(transform); + + this.head = null; + this.hmd = null; + this.leftHand = null; + this.rightHand = null; } Start() @@ -34,13 +36,15 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; } - createTransform(t, name) + createTransform(k) { + let t = this[k]; if (t === null) { - t = new GameObject(name).AddComponent(); + t = new GameObject(name).AddComponent(StaticOffsetTransform); t.transform.parent = transform; this.setStaticOffsetSettings(t); + this[k] = t; } } @@ -56,10 +60,10 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; createTransforms() { - this.createTransform(head, nameof(head)); - this.createTransform(leftHand, nameof(leftHand)); - this.createTransform(rightHand, nameof(rightHand)); - this.createTransform(hmd, nameof(hmd)); + this.createTransform('head'); + this.createTransform('leftHand'); + this.createTransform('rightHand'); + this.createTransform('hmd'); } connectTransforms() diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 7ca5c25..3400808 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -1,44 +1,49 @@ -import {Vector3, Transform} from './Unity.js'; +import {Vector3, Transform, MonoBehavior} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; +import ShoulderPoser from './ShoulderPoser.js'; -class ShoulderTransforms +function Instantiate() { + // XXX +} + +class ShoulderTransforms extends MonoBehavior { - constructor() { + constructor(transform) { + constructor(transform); + this.leftShoulder = new Transform(); this.rightShoulder = new Transform(); this.leftShoulderRenderer = new Transform(); this.rightShoulderRenderer = new Transform(); this.leftShoulderAnchor = Transform(); this.rightShoulderAnchor = Transform(); - this.leftArmDummy = new ArmTransforms(); - this.rightArmDummy = new ArmTransforms(); - this.leftArm = new ArmTransforms(); - this.rightArm = new ArmTransforms(); + this.leftArm = null; + this.rightArm = null; } Awake() { if (leftArm == null) { - leftArm = Instantiate(leftArmDummy, leftShoulderAnchor.position, leftShoulderAnchor.rotation, leftShoulderAnchor); - var armIk = leftArm.GetComponentInChildren(); + this.leftArm = new ArmTransforms(); + const armIk = leftArm.GetComponentInChildren(VRArmIK); armIk.shoulder = this; - armIk.shoulderPoser = GetComponent(); + armIk.shoulderPoser = this.GetComponent(ShoulderPoser); armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; } if (rightArm == null) { - rightArm = Instantiate(rightArmDummy, leftShoulderAnchor.position, rightShoulderAnchor.rotation, rightShoulderAnchor); - var armIk = rightArm.GetComponentInChildren(); + this.rightArm = new ArmTransforms(); + const armIk = rightArm.GetComponentInChildren(VRArmIK); armIk.shoulder = this; - armIk.shoulderPoser = GetComponent(); + armIk.shoulderPoser = this.GetComponent(ShoulderPoser); armIk.target = armIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; } } Start() { - setShoulderWidth(PoseManager.Instance.playerWidthShoulders); + this.setShoulderWidth(PoseManager.Instance.playerWidthShoulders); } setShoulderWidth(width) diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index 369a414..a20e692 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion} from './Unity.js'; +import {Vector3, Quaternion, MonoBehavior} from './Unity.js'; const EulerOrder = { XYZ: 'XYZ', @@ -9,9 +9,11 @@ const EulerOrder = { ZYX: 'ZYX', }; -class StaticOffsetTransform +class StaticOffsetTransform extends MonoBehavior { - constructor() { + constructor(transform) { + super(transform); + this.reference = null; this.offsetPosition = new Vector3(); this.offsetRotation = new Vector3(); diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 57bb636..239b247 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,8 +1,8 @@ -import {Vector3, Quaternion, Transform} from './Unity.js'; +import {Vector3, Quaternion, Transform, MonoBehavior} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; -import VectorHelpers from 'Utils/VectorHelpers.js'; +import VectorHelpers from './Utils/VectorHelpers.js'; class ArmIKElbowSettings { @@ -63,10 +63,12 @@ class HandSettings } } - class VRArmIK + class VRArmIK extends MonoBehavior { - constructor() { - this.arm = new ArmTransforms(); // XXX these need to be this'd below + constructor(transform) { + super(transform); + + this.arm = new ArmTransforms(); this.shoulder = new ShoulderTransforms(); this.shoulderPoser = new ShoulderPoser(); this.target = new Transform(); @@ -93,7 +95,7 @@ class HandSettings this.upperArmStartRotation = this.arm.upperArm.rotation; this.lowerArmStartRotation = this.arm.lowerArm.rotation; this.wristStartRotation = Quaternion.identity; - if (this.arm.wrist1 != null) + if (this.arm.wrist1 !== null) wthis.ristStartRotation = arm.wrist1.rotation; this.handStartRotation = arm.hand.rotation; } From 1b45f7509fdf1c9b8c29ac3e8f061c9c488ad3c1 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 01:44:09 -0400 Subject: [PATCH 052/562] Small vrarmik debugging --- vrarmik/ShoulderPoser.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index a3a6cdf..2a377db 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -92,7 +92,7 @@ class ShoulderPoser this.shoulder.rightArm.transform.localPosition = Vector3.zero; } - Debug.DrawRay(this.shoulder.transform.position, this.shoulder.transform.forward); + // Debug.DrawRay(this.shoulder.transform.position, this.shoulder.transform.forward); } rotateLeftShoulder() From 77db25e1262011b1c184ad15424bca320ef8b75c Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 02:02:11 -0400 Subject: [PATCH 053/562] More vrarmik debugging --- vrarmik/AvatarVRTrackingReferences.js | 4 ++-- vrarmik/ShoulderPoser.js | 11 +++++++---- vrarmik/ShoulderTransforms.js | 6 +++--- vrarmik/Unity.js | 4 ++-- 4 files changed, 14 insertions(+), 11 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 6092960..cbf635b 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,8 +1,8 @@ -import {Vector3, GameObject, MonoBehaviour} from './Unity.js'; +import {Vector3, GameObject, MonoBehavior} from './Unity.js'; import StaticOffsetTransform from './StaticOffsetTransform.js'; - class AvatarVRTrackingReferences extends MonoBehaviour + class AvatarVRTrackingReferences extends MonoBehavior { constructor(transform) { super(transform); diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 2a377db..01f9036 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,14 +1,17 @@ -import {Vector3, Quaternion} from './Unity.js'; +import {Vector3, Quaternion, MonoBehavior} from './Unity.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import VRTrackingReferences from './VRTrackingReferences.js'; +import AvatarVRTrackingReferences from './AvatarVRTrackingReferences.js'; import PoseManager from './PoseManager.js'; -class ShoulderPoser +class ShoulderPoser extends MonoBehavior { - constructor() { + constructor(transform) { + super(transform); + this.shoulder = new ShoulderTransforms(); this.vrTrackingReferences = new VRTrackingReferences(); - this.avatarTrackingReferences = AvatarVRTrackingReferences(); + this.avatarTrackingReferences = new AvatarVRTrackingReferences(); this.headNeckDistance = 0.03; this.neckShoulderDistance = new Vector3(0, -.1, -0.02); diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 3400808..b82a134 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -9,14 +9,14 @@ function Instantiate() { class ShoulderTransforms extends MonoBehavior { constructor(transform) { - constructor(transform); + super(transform); this.leftShoulder = new Transform(); this.rightShoulder = new Transform(); this.leftShoulderRenderer = new Transform(); this.rightShoulderRenderer = new Transform(); - this.leftShoulderAnchor = Transform(); - this.rightShoulderAnchor = Transform(); + this.leftShoulderAnchor = new Transform(); + this.rightShoulderAnchor = new Transform(); this.leftArm = null; this.rightArm = null; } diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index a33948b..0a5fef6 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -161,8 +161,8 @@ class Transform { this._parent = null; - this._matrix = new THREE,Matrix4(); - this._matrixWorld = new THREE,Matrix4(); + this._matrix = new THREE.Matrix4(); + this._matrixWorld = new THREE.Matrix4(); } get position() { From b6589e0c8dd2a9d40470ed479c8b95678181bc7b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 15:33:02 -0400 Subject: [PATCH 054/562] Bugfix wrist start location --- vrarmik/VRArmIK.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 239b247..29ef9c8 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -96,7 +96,7 @@ class HandSettings this.lowerArmStartRotation = this.arm.lowerArm.rotation; this.wristStartRotation = Quaternion.identity; if (this.arm.wrist1 !== null) - wthis.ristStartRotation = arm.wrist1.rotation; + this.wristStartRotation = arm.wrist1.rotation; this.handStartRotation = arm.hand.rotation; } From 87c41c43a530bc3da79cf3bbdbf05b014cb6ab4d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:45:42 -0400 Subject: [PATCH 055/562] Re-connect missing StaticOffsetTransform component --- vrarmik/AvatarVRTrackingReferences.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index cbf635b..d1f64dc 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -68,11 +68,11 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; connectTransforms() { - /* const sot = this.GetOrAddComponent(StaticOffsetTransform); + const sot = this.GetOrAddComponent(StaticOffsetTransform); if (sot.reference === null) { - sot.reference = transform.parent; - } */ + sot.reference = this.transform.parent; + } this.head.reference = this.head.reference !== null ? this.head.reference : PoseManager.Instance.vrTransforms.head; this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : PoseManager.Instance.vrTransforms.hmd; From 4545e507708ac0dea22395f746791ae90d04635d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:47:23 -0400 Subject: [PATCH 056/562] Comment out calibration code --- vrarmik/ArmTransforms.js | 2 +- vrarmik/PoseManager.js | 8 ++++---- vrarmik/ShoulderPoser.js | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 03ae8c9..b03bb2b 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -33,7 +33,7 @@ class ArmTransforms extends MonoBehavior Start() { - PoseManager.Instance.onCalibrate += this.updateArmLengths; + // PoseManager.Instance.onCalibrate += this.updateArmLengths; this.updateArmLengths(); } diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 0a41f34..9ea4c43 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -41,7 +41,7 @@ class PoseManager this.vrSystemOffsetHeight = string.IsNullOrEmpty(device) || device == "OpenVR" ? 0 : this.playerHeightHmd; } - Start() + /* Start() { onCalibrate += OnCalibrate; } @@ -49,7 +49,7 @@ class PoseManager OnCalibrate() { this.playerHeightHmd = Camera.main.transform.position.y; - } + } */ loadPlayerWidthShoulders() { @@ -61,7 +61,7 @@ class PoseManager PlayerPrefs.SetFloat("VRArmIK_PlayerWidthShoulders", width); } - calibrateIK() + /* calibrateIK() { this.playerWidthWrist = (this.vrTransforms.leftHand.position - this.vrTransforms.rightHand.position).magnitude; this.playerHeightHmd = this.vrTransforms.hmd.position.y; @@ -74,7 +74,7 @@ class PoseManager PlayerPrefs.SetFloat("VRArmIK_PlayerWidthWrist", this.widthWrist); this.loadPlayerSize(); this.onCalibrate && this.onCalibrate.Invoke(); - } + } */ loadPlayerSize() { diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 01f9036..3d0b0d9 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -64,13 +64,13 @@ class ShoulderPoser extends MonoBehavior this.shoulder.transform.InverseTransformPoint(this.shoulder.rightShoulderAnchor.position); } - onCalibrate() + /* onCalibrate() { this.shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.transform.position - this.shoulder.leftShoulderAnchor.position) .magnitude); this.shoulder.rightArm.setArmLength((avatarTrackingReferences.rightHand.transform.position - this.shoulder.rightShoulderAnchor.position) .magnitude); - } + } */ Update() { From 8875c50c704a1888473d20fa5deb436af79c2dee Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:47:48 -0400 Subject: [PATCH 057/562] Bugfix Unity Vector3 change code --- vrarmik/Unity.js | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 0a5fef6..fe53d3d 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -2,15 +2,6 @@ const DEG2RAD = Math.PI/180; const RAD2DEG = 180/Math.PI; class Vector3 extends THREE.Vector3 { - set(x, y, z) { - super.set(x, y, z); - this.onchange && this.onchange(); - } - copy(p) { - super.copy(p); - this.onchange && this.onchange(); - } - bindOnchange(onchange) { let x = this.x, y = this.y, z = this.z; Object.defineProperty(this, 'x', { @@ -40,6 +31,14 @@ class Vector3 extends THREE.Vector3 { onchange(); }, }); + this.set = (_set => function set() { + _set.apply(this, arguments); + onchange(); + })(this.set); + this.copy = (_copy => function copy() { + _copy.apply(this, arguments); + onchange(); + })(this.copy); } static get zero() { From 5e27e09230b91a5697eacec467aa70b56969a983 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:48:20 -0400 Subject: [PATCH 058/562] Bugfix Unity Quaternion change code --- vrarmik/Unity.js | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index fe53d3d..77ff7a5 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -77,15 +77,6 @@ class Vector3 extends THREE.Vector3 { } class Quaternion extends THREE.Quaternion { - set(x, y, z, w) { - super.set(x, y, z, w); - this.onchange && this.onchange(); - } - copy(p) { - super.copy(p); - this.onchange && this.onchange(); - } - bindOnchange(onchange) { let x = this.x, y = this.y, z = this.z, w = this.w; Object.defineProperty(this, 'x', { @@ -124,6 +115,14 @@ class Quaternion extends THREE.Quaternion { onchange(); }, }); + this.set = (_set => function set() { + _set.apply(this, arguments); + onchange(); + })(this.set); + this.copy = (_copy => function copy() { + _copy.apply(this, arguments); + onchange(); + })(this.copy); } static get identity() { From fdfb9c5fd44c285d31819a9a30b3f1a7b2b81baf Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:48:50 -0400 Subject: [PATCH 059/562] Ensure Unity MonoBehavior transform is always present --- vrarmik/Unity.js | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 77ff7a5..c3b7b6b 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -249,7 +249,11 @@ class GameObject { } class MonoBehavior { - constructor(transform = new Transform()) { + constructor(transform) { + if (!transform) { + throw new Error('bad component initialization'); + } + this.transform = transform; this.components = new Map(); } From cad20d66227087511201cfad27aaaa329fe5aef9 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:49:41 -0400 Subject: [PATCH 060/562] Bugfix avatar vr tracking references --- vrarmik/AvatarVRTrackingReferences.js | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index d1f64dc..ceaf78d 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,4 +1,5 @@ import {Vector3, GameObject, MonoBehavior} from './Unity.js'; +import PoseManager from './PoseManager.js'; import StaticOffsetTransform from './StaticOffsetTransform.js'; @@ -41,8 +42,8 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; let t = this[k]; if (t === null) { - t = new GameObject(name).AddComponent(StaticOffsetTransform); - t.transform.parent = transform; + t = new GameObject(name).GetComponent(StaticOffsetTransform); + t.transform.parent = this.transform; this.setStaticOffsetSettings(t); this[k] = t; } @@ -76,7 +77,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; this.head.reference = this.head.reference !== null ? this.head.reference : PoseManager.Instance.vrTransforms.head; this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : PoseManager.Instance.vrTransforms.hmd; - this.leftHand.reference = leftHand.reference !== null + this.leftHand.reference = this.leftHand.reference !== null ? this.leftHand.reference : PoseManager.Instance.vrTransforms.leftHand; this.rightHand.reference = this.rightHand.reference !== null From 9c8363ecafdd2000656249325d6a079ed104b674 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:49:58 -0400 Subject: [PATCH 061/562] Bugfix vr tracking references --- vrarmik/VRTrackingReferences.js | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index 6f57b90..0f9ac37 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -1,8 +1,10 @@ -import {Transform} from './Unity.js'; +import {Transform, MonoBehavior} from './Unity.js'; - class VRTrackingReferences + class VRTrackingReferences extends MonoBehavior { - constructor() { + constructor(transform) { + super(transform); + this.leftController = new Transform(); this.rightController = new Transform(); this.hmd = new Transform(); From 5d8e41b726f922cfd25a93a47be4eb2bfb96c21b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:51:37 -0400 Subject: [PATCH 062/562] PoseManager debugging --- vrarmik/PoseManager.js | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 9ea4c43..f971788 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -1,11 +1,15 @@ import VRTrackingReferences from './VRTrackingReferences.js'; -import {XRSettings} from './Unity.js'; +import AvatarVRTrackingReferences from './AvatarVRTrackingReferences.js'; +import {GameObject, MonoBehavior, XRSettings} from './Unity.js'; -class PoseManager +class PoseManager extends MonoBehavior { - constructor() { - this.vrTransforms = new VRTrackingReferences(); - this.OnCalibrateListener = null; + constructor(transform) { + super(transform); + + this.vrTransforms = new GameObject().AddComponent(VRTrackingReferences); + this.avatarVrTransforms = new GameObject().AddComponent(AvatarVRTrackingReferences); + // this.OnCalibrateListener = null; // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. // In OpenVR, the 0 position is the ground position and the user is then at (0, playerHeightHmd, 0) if he is in the middle of the room, so I need to correct this for shoulder calculation @@ -38,7 +42,7 @@ class PoseManager this.loadPlayerSize(); } const device = XRSettings.loadedDeviceName; - this.vrSystemOffsetHeight = string.IsNullOrEmpty(device) || device == "OpenVR" ? 0 : this.playerHeightHmd; + this.vrSystemOffsetHeight = /*string.IsNullOrEmpty(device) || */device == "OpenVR" ? 0 : this.playerHeightHmd; } /* Start() From ea3d75d693d7fa916ca915396c2fabf7c48d156a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:51:49 -0400 Subject: [PATCH 063/562] ShoulderPoser debugging --- vrarmik/ShoulderPoser.js | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 3d0b0d9..fe8ab72 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -9,9 +9,9 @@ class ShoulderPoser extends MonoBehavior constructor(transform) { super(transform); - this.shoulder = new ShoulderTransforms(); - this.vrTrackingReferences = new VRTrackingReferences(); - this.avatarTrackingReferences = new AvatarVRTrackingReferences(); + this.shoulder = new GameObject().GetComponent(ShoulderTransforms); + this.vrTrackingReferences = null; + this.avatarTrackingReferences = null; this.headNeckDistance = 0.03; this.neckShoulderDistance = new Vector3(0, -.1, -0.02); @@ -52,12 +52,16 @@ class ShoulderPoser extends MonoBehavior this.leftShoulderAnkerStartLocalPosition = new Vector3(); this.rightShoulderAnkerStartLocalPosition = new Vector3(); + + this.Start(); } Start() { if (this.vrTrackingReferences === null) this.vrTrackingReferences = PoseManager.Instance.vrTransforms; + if (this.avatarTrackingReferences === null) + this.avatarTrackingReferences = PoseManager.Instance.avatarVrTransforms; this.leftShoulderAnkerStartLocalPosition = this.shoulder.transform.InverseTransformPoint(this.shoulder.leftShoulderAnchor.position); this.rightShoulderAnkerStartLocalPosition = From 25743e4f660c490c9d5c46ec9f7954d2c9a48c51 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:52:03 -0400 Subject: [PATCH 064/562] ShoulderTransforms debugging --- vrarmik/ShoulderTransforms.js | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index b82a134..f6e22e5 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -1,10 +1,7 @@ -import {Vector3, Transform, MonoBehavior} from './Unity.js'; +import {Vector3, Transform, GameObject, MonoBehavior} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; - -function Instantiate() { - // XXX -} +import VRArmIK from './VRArmIK.js'; class ShoulderTransforms extends MonoBehavior { @@ -23,18 +20,18 @@ class ShoulderTransforms extends MonoBehavior Awake() { - if (leftArm == null) + if (this.leftArm === null) { - this.leftArm = new ArmTransforms(); - const armIk = leftArm.GetComponentInChildren(VRArmIK); + this.leftArm = new GameObject().AddComponent(ArmTransforms); + const armIk = this.leftArm.GetComponentInChildren(VRArmIK); armIk.shoulder = this; armIk.shoulderPoser = this.GetComponent(ShoulderPoser); armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; } - if (rightArm == null) + if (rightArm === null) { - this.rightArm = new ArmTransforms(); - const armIk = rightArm.GetComponentInChildren(VRArmIK); + this.rightArm = new GameObject().AddComponent(ArmTransforms); + const armIk = this.rightArm.GetComponentInChildren(VRArmIK); armIk.shoulder = this; armIk.shoulderPoser = this.GetComponent(ShoulderPoser); armIk.target = armIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; From d71035ceb73df9f72b1a93845cccd6173981ebd3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:52:16 -0400 Subject: [PATCH 065/562] StaticOffsetTransform debugging --- vrarmik/StaticOffsetTransform.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index a20e692..e9216e1 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -68,7 +68,7 @@ class StaticOffsetTransform extends MonoBehavior if (this.reference === null) return; - const rot = this.switchAxis(this.referenceLocalRotation ? reference.localEulerAngles : reference.eulerAngles, this.axisOrder) + + const rot = this.switchAxis(this.referenceLocalRotation ? this.reference.localEulerAngles : this.reference.eulerAngles, this.axisOrder) + this.offsetRotation; rot.Scale(referenceRotationMultiplicator); From 2ee4e7c02cf9b678631cadc1389ea8f8a90ad620 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:52:45 -0400 Subject: [PATCH 066/562] Unity GameObject/MonoBehavior debugging --- vrarmik/Unity.js | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index c3b7b6b..07b75d5 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -237,15 +237,35 @@ class Transform { } } +const gameObjects = []; class GameObject { constructor(name) { this.name = name; this.transform = new Transform(); } - AddComponent(Constructor) { return new Constructor(this.transform); } + AddChild(child) { + child.transform.parent = this; + } + static startAll() { + for (let i = 0; i < gameObjects.length; i++) { + gameObjects[i].components.forEach(value => { + value.Awake(); + value.OnEnable(); + value.Start(); + }); + } + } + static updateAll() { + for (let i = 0; i < gameObjects.length; i++) { + gameObjects[i].components.forEach(value => { + value.Update(); + value.LateUpdate(); + }); + } + } } class MonoBehavior { @@ -272,6 +292,13 @@ class MonoBehavior { GetComponentInChildren(Constructor) { return this.GetComponent(Constructor); } + + Awake() {} + OnEnable() {} + Start() {} + + Update() {} + LateUpdate() {} } const Mathf = { From acc9af18796a4ee0602b86d0d719ddde4503b4de Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 13 Oct 2019 22:53:16 -0400 Subject: [PATCH 067/562] Bugfix VRArmIK --- vrarmik/VRArmIK.js | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 29ef9c8..ad9b3d6 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -68,15 +68,15 @@ class HandSettings constructor(transform) { super(transform); - this.arm = new ArmTransforms(); - this.shoulder = new ShoulderTransforms(); - this.shoulderPoser = new ShoulderPoser(); + this.arm = new GameObject().GetComponent(ArmTransforms); + this.shoulder = null; + this.shoulderPoser = null; this.target = new Transform(); this.left = true; this.elbowSettings = new ArmIKElbowSettings(); this.beforePositioningSettings = new BeforePositioningSettings(); - this.elbowCorrectionSettings = ElbowCorrectionSettings(); + this.elbowCorrectionSettings = new ElbowCorrectionSettings(); this.handSettings = new HandSettings(); this.nextLowerArmAngle = new Vector3(); @@ -96,8 +96,8 @@ class HandSettings this.lowerArmStartRotation = this.arm.lowerArm.rotation; this.wristStartRotation = Quaternion.identity; if (this.arm.wrist1 !== null) - this.wristStartRotation = arm.wrist1.rotation; - this.handStartRotation = arm.hand.rotation; + this.wristStartRotation = this.arm.wrist1.rotation; + this.handStartRotation = this.arm.hand.rotation; } OnEnable() From 334bbe9cf1cb562cbd14b8900c357031b2fb4056 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 03:42:49 -0400 Subject: [PATCH 068/562] Bugfix Unity includes --- vrarmik/ArmTransforms.js | 2 +- vrarmik/ShoulderPoser.js | 3 ++- vrarmik/ShoulderTransforms.js | 2 ++ vrarmik/VRArmIK.js | 2 +- 4 files changed, 6 insertions(+), 3 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index b03bb2b..23694fd 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,4 +1,4 @@ -import {Vector3, Transform, MonoBehavior} from './Unity.js'; +import {Vector3, Transform, MonoBehavior, Mathf} from './Unity.js'; import PoseManager from './PoseManager.js'; class ArmTransforms extends MonoBehavior diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index fe8ab72..df17718 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,8 +1,9 @@ -import {Vector3, Quaternion, MonoBehavior} from './Unity.js'; +import {Vector3, Quaternion, GameObject, MonoBehavior, Mathf} from './Unity.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import VRTrackingReferences from './VRTrackingReferences.js'; import AvatarVRTrackingReferences from './AvatarVRTrackingReferences.js'; import PoseManager from './PoseManager.js'; +import VectorHelpers from './Utils/VectorHelpers.js'; class ShoulderPoser extends MonoBehavior { diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index f6e22e5..4ccbc42 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -2,6 +2,8 @@ import {Vector3, Transform, GameObject, MonoBehavior} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; import VRArmIK from './VRArmIK.js'; +import PoseManager from './PoseManager.js'; + class ShoulderTransforms extends MonoBehavior { diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index ad9b3d6..3046f04 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion, Transform, MonoBehavior} from './Unity.js'; +import {Vector3, Quaternion, Transform, GameObject, MonoBehavior, Mathf} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; From 4f6cf007de9ee0602bc616bdd6590d732926df3b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 03:47:25 -0400 Subject: [PATCH 069/562] Unity bugfixing --- vrarmik/ArmTransforms.js | 4 +- vrarmik/AvatarVRTrackingReferences.js | 4 +- vrarmik/PoseManager.js | 4 +- vrarmik/ShoulderPoser.js | 4 +- vrarmik/ShoulderTransforms.js | 4 +- vrarmik/StaticOffsetTransform.js | 4 +- vrarmik/Unity.js | 71 +++++++++++++++++++++------ vrarmik/VRArmIK.js | 4 +- vrarmik/VRTrackingReferences.js | 4 +- 9 files changed, 72 insertions(+), 31 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 23694fd..e44cbbc 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -3,8 +3,8 @@ import PoseManager from './PoseManager.js'; class ArmTransforms extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.upperArm = new Transform(); this.lowerArm = new Transform(); diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index ceaf78d..4517cfe 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -5,8 +5,8 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; class AvatarVRTrackingReferences extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.head = null; this.hmd = null; diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index f971788..d6e141b 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -4,8 +4,8 @@ import {GameObject, MonoBehavior, XRSettings} from './Unity.js'; class PoseManager extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.vrTransforms = new GameObject().AddComponent(VRTrackingReferences); this.avatarVrTransforms = new GameObject().AddComponent(AvatarVRTrackingReferences); diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index df17718..93add01 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -7,8 +7,8 @@ import VectorHelpers from './Utils/VectorHelpers.js'; class ShoulderPoser extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.shoulder = new GameObject().GetComponent(ShoulderTransforms); this.vrTrackingReferences = null; diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 4ccbc42..2b5a892 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -7,8 +7,8 @@ import PoseManager from './PoseManager.js'; class ShoulderTransforms extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.leftShoulder = new Transform(); this.rightShoulder = new Transform(); diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index e9216e1..eb59320 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -11,8 +11,8 @@ const EulerOrder = { class StaticOffsetTransform extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.reference = null; this.offsetPosition = new Vector3(); diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 07b75d5..40f4f95 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -165,53 +165,71 @@ class Transform { get position() { this.updateMatrixWorld(); - return this._position; + return this._position.clone(); } set position(position) { this._position.copy(position); } get rotation() { this.updateMatrixWorld(); - return this._rotation; + return this._rotation.clone(); } set rotation(rotation) { this._rotation.copy(rotation); } get scale() { this.updateMatrixWorld(); - return this._scale; + return this._scale.clone(); } set scale(scale) { this._scale.copy(scale); } get localPosition() { - return this._localPosition; + return this._localPosition.clone(); } set localPosition(localPosition) { this._localPosition.copy(localPosition); } get localRotation() { - return this._localRotation; + return this._localRotation.clone(); } set localRotation(localRotation) { this._localRotation.copy(localRotation); } get localScale() { - return this._localScale; + return this._localScale.clone(); } set localScale(localScale) { this._localScale.copy(localScale); } + get parent() { + return this._parent; + } + set parent(parent) { + this._parent = parent; + this.matrixWorldNeedsUpdate = true; + } + + get right() { + return this.TransformPoint(Vector3.right); + } + get up() { + return this.TransformPoint(Vector3.up); + } + get forward() { + return this.TransformPoint(Vector3.forward); + } + updateMatrixWorld() { if (this.matrixWorldNeedsUpdate) { this._matrix.compose(this._position, this._rotation, this._scale); this._matrixWorld.copy(this._matrix); - if (t.parent) { - t.parent.updateMatrixWorld(); - this._matrixWorld.premultiply(t.parent._matrixWorld); + if (this._parent) { + this._parent.updateMatrixWorld(); + this._matrixWorld.premultiply(this._parent._matrixWorld); } this._matrixWorld.decompose(this._position, this._rotation, this._scale); @@ -241,19 +259,38 @@ const gameObjects = []; class GameObject { constructor(name) { this.name = name; + this.transform = new Transform(); + this.components = new Map(); + this.children = []; + + gameObjects.push(this); } AddComponent(Constructor) { - return new Constructor(this.transform); + let component = this.components.get(Constructor); + if (component === undefined) { + component = new Constructor(this.transform, this.components); + this.components.set(Constructor, component); + } + return component; } AddChild(child) { - child.transform.parent = this; + this.children.push(child); + child.transform.parent = this.transform; } static startAll() { for (let i = 0; i < gameObjects.length; i++) { gameObjects[i].components.forEach(value => { value.Awake(); + }); + } + for (let i = 0; i < gameObjects.length; i++) { + gameObjects[i].components.forEach(value => { value.OnEnable(); + }); + } + for (let i = 0; i < gameObjects.length; i++) { + gameObjects[i].components.forEach(value => { value.Start(); }); } @@ -262,6 +299,10 @@ class GameObject { for (let i = 0; i < gameObjects.length; i++) { gameObjects[i].components.forEach(value => { value.Update(); + }); + } + for (let i = 0; i < gameObjects.length; i++) { + gameObjects[i].components.forEach(value => { value.LateUpdate(); }); } @@ -269,19 +310,19 @@ class GameObject { } class MonoBehavior { - constructor(transform) { - if (!transform) { + constructor(transform, components) { + if (!transform || !components) { throw new Error('bad component initialization'); } this.transform = transform; - this.components = new Map(); + this.components = components; } GetComponent(Constructor) { let component = this.components.get(Constructor); if (component === undefined) { - component = new Constructor(this.transform); + component = new Constructor(this.transform, this.components); this.components.set(Constructor, component); } return component; diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 3046f04..029bc55 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -65,8 +65,8 @@ class HandSettings class VRArmIK extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.arm = new GameObject().GetComponent(ArmTransforms); this.shoulder = null; diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index 0f9ac37..50511a5 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -2,8 +2,8 @@ import {Transform, MonoBehavior} from './Unity.js'; class VRTrackingReferences extends MonoBehavior { - constructor(transform) { - super(transform); + constructor(...args) { + super(...args); this.leftController = new Transform(); this.rightController = new Transform(); From 4d1f703ddff6974d2f1353527cdc3bf646a1cdd9 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 03:48:06 -0400 Subject: [PATCH 070/562] Unity Vector3 bugfixing --- vrarmik/Unity.js | 38 +++++++++++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 40f4f95..bdf4e89 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -1,6 +1,15 @@ const DEG2RAD = Math.PI/180; const RAD2DEG = 180/Math.PI; +class Vector2 extends THREE.Vector2 { + get magnitude() { + return this.length(); + } + get normalized() { + return this.clone().normalize(); + } +} + class Vector3 extends THREE.Vector3 { bindOnchange(onchange) { let x = this.x, y = this.y, z = this.z; @@ -47,32 +56,47 @@ class Vector3 extends THREE.Vector3 { static get one() { return new Vector3(1, 1, 1); } + static get left() { + return new Vector3(-1, 0, 0); + } static get right() { return new Vector3(1, 0, 0); } static get up() { return new Vector3(0, 1, 0); } + static get down() { + return new Vector3(0, -1, 0); + } static get forward() { return new Vector3(0, 0, 1); } + static get back() { + return new Vector3(0, 0, -1); + } get magnitude() { return this.length(); } get normalized() { return this.clone().normalize(); } - Scale(a, b) { + xz() { + return new Vector2(this.x, this.z); + } + static Scale(a, b) { return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z); } - Dot(v) { - return this.dot(v); + Scale(v) { + return new Vector3(this.x + v.x, this.y + v.y, this.z + v.z); + } + static Dot(a, b) { + return a.dot(b); } - Cross(v) { - return this.clone().cross(v); + static Cross(a, b) { + return a.clone().cross(b); } - Angle(v) { - return this.angleTo(v) * RAD2DEG; + static Angle(a, b) { + return a.angleTo(b) * RAD2DEG; } } From 83d217557f7759148bff39ea1b0a1f74b2af8eea Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 03:48:26 -0400 Subject: [PATCH 071/562] Unity Quaternion bugfixing --- vrarmik/Unity.js | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index bdf4e89..0fbb111 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -159,7 +159,10 @@ class Quaternion extends THREE.Quaternion { return new Quaternion().setFromUnitVectors(a, b); } static Euler(v) { - return new Quaternion().setFromEuler(new Euler(v.x, v.y, v.z, 'ZXY')); + return new Quaternion().setFromEuler(new THREE.Euler(v.x, v.y, v.z, 'ZXY')); + } + static Inverse(q) { + return q.clone().inverse(); } Inverse() { From e54819276d5264214de47ca4d7eede2a602b7799 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 03:48:35 -0400 Subject: [PATCH 072/562] Unity Transform bugfixing --- vrarmik/Unity.js | 27 +++++++++++++++++++++++---- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 0fbb111..809991a 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -272,13 +272,32 @@ class Transform { const e = new THREE.Euler().setFromQuaternion(this.rotation, 'ZXY'); return new Vector3(e.x, e.y, e.z); } + set eulerAngles(v) { + this.rotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(v.x, v.y, v.z, 'ZXY')); + } + get localEulerAngles() { + const e = new THREE.Euler().setFromQuaternion(this.localRotation, 'ZXY'); + return new Vector3(e.x, e.y, e.z); + } + set localEulerAngles(v) { + this.localRotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(v.x, v.y, v.z, 'ZXY')); + } + TransformPoint(v) { - return v.applyMatrix4(new THREE.Matrix4().compose(this.position, this.rotation, this.scale)); + this.updateMatrixWorld(); + return v.clone().applyMatrix4(this._matrixWorld); } InverseTransformPoint(v) { - const m = new THREE.Matrix4().compose(this.position, this.rotation, this.scale); - m.getInverse(m); - return v.applyMatrix4(m); + this.updateMatrixWorld(); + return v.clone().applyMatrix4(new THREE.Matrix4().getInverse(this._matrixWorld)); + } + TransformDirection(v) { + this.updateMatrixWorld(); + return v.clone().applyMatrix4(this._matrixWorld).normalize(); + } + InverseTransformDirection(v) { + this.updateMatrixWorld(); + return v.clone().applyMatrix4(new THREE.Matrix4().getInverse(this._matrixWorld)).normalize(); } } From 3134a164088b3eb1c855f89642821c2207aac8f2 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 04:23:00 -0400 Subject: [PATCH 073/562] Typo debugging --- vrarmik/ArmTransforms.js | 4 ++-- vrarmik/AvatarVRTrackingReferences.js | 4 ++-- vrarmik/PoseManager.js | 6 ++++-- vrarmik/ShoulderTransforms.js | 13 +++++++------ vrarmik/Unity.js | 5 +++++ 5 files changed, 20 insertions(+), 12 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index e44cbbc..89883ba 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -46,7 +46,7 @@ class ArmTransforms extends MonoBehavior setUpperArmLength(length) { - if (armLengthByScale) + if (this.armLengthByScale) { const oldLowerArmLength = distance(this.lowerArm, this.hand); @@ -81,7 +81,7 @@ class ArmTransforms extends MonoBehavior setArmLength(length) { const upperArmFactor = .48; - if (armLengthByScale) + if (this.armLengthByScale) { this.upperArm.localScale = this.upperArm.localScale / this.armLength * length; this.hand.localScale = Vector3.one / (1 - (1 - this.scaleHandFactor) * (1 - this.upperArm.localScale.x)); diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 4517cfe..f1a3851 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -69,11 +69,11 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; connectTransforms() { - const sot = this.GetOrAddComponent(StaticOffsetTransform); + /* const sot = this.GetOrAddComponent(StaticOffsetTransform); if (sot.reference === null) { sot.reference = this.transform.parent; - } + } */ this.head.reference = this.head.reference !== null ? this.head.reference : PoseManager.Instance.vrTransforms.head; this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : PoseManager.Instance.vrTransforms.hmd; diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index d6e141b..ac2ab4d 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -21,9 +21,11 @@ class PoseManager extends MonoBehavior this.playerWidthWrist = 1.39; this.playerWidthShoulders = 0.31; this.loadPlayerSizeOnAwake = false; + + PoseManager.Instance = this; } - OnEnable() + /* OnEnable() { if (PoseManager.Instance === null) { @@ -33,7 +35,7 @@ class PoseManager extends MonoBehavior { Debug.LogError("Multiple Instances of PoseManager in Scene"); } - } + } */ Awake() { diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 2b5a892..1960e19 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -11,9 +11,10 @@ class ShoulderTransforms extends MonoBehavior super(...args); this.leftShoulder = new Transform(); + this.rightShoulder = new Transform(); - this.leftShoulderRenderer = new Transform(); - this.rightShoulderRenderer = new Transform(); + /* this.leftShoulderRenderer = new Transform(); + this.rightShoulderRenderer = new Transform(); */ this.leftShoulderAnchor = new Transform(); this.rightShoulderAnchor = new Transform(); this.leftArm = null; @@ -30,7 +31,7 @@ class ShoulderTransforms extends MonoBehavior armIk.shoulderPoser = this.GetComponent(ShoulderPoser); armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; } - if (rightArm === null) + if (this.rightArm === null) { this.rightArm = new GameObject().AddComponent(ArmTransforms); const armIk = this.rightArm.GetComponentInChildren(VRArmIK); @@ -40,7 +41,7 @@ class ShoulderTransforms extends MonoBehavior } } - Start() + /* Start() { this.setShoulderWidth(PoseManager.Instance.playerWidthShoulders); } @@ -51,11 +52,11 @@ class ShoulderTransforms extends MonoBehavior const localPosition = new Vector3(width * .25, 0, 0); leftShoulderRenderer.localScale = localScale; - leftShoulderRenderer.localPosition = -localPosition; + leftShoulderRenderer.localPosition = localPosition.clone().multiplyScalar(-1); rightShoulderRenderer.localScale = localScale; rightShoulderRenderer.localPosition = localPosition; - } + } */ } export default ShoulderTransforms; diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 809991a..f0374d7 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -388,6 +388,10 @@ class MonoBehavior { LateUpdate() {} } +const Time = { + deltaTime: 1/90, +}; + const Mathf = { Deg2Rad: DEG2RAD, Rad2Deg: RAD2DEG, @@ -471,6 +475,7 @@ export { Transform, GameObject, MonoBehavior, + Time, Mathf, PlayerPrefs, XRSettings, From acc24361b589b6281627bfd57a51801a3e235637 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 04:23:32 -0400 Subject: [PATCH 074/562] Add missing Time import --- vrarmik/VRArmIK.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 029bc55..24baeed 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion, Transform, GameObject, MonoBehavior, Mathf} from './Unity.js'; +import {Vector3, Quaternion, Transform, GameObject, MonoBehavior, Time, Mathf} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; From 17dccd07890b60d475e40dbbc1343b7e08c3a22d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 04:24:18 -0400 Subject: [PATCH 075/562] Bugfix initialization order --- vrarmik/AvatarVRTrackingReferences.js | 2 +- vrarmik/ShoulderTransforms.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index f1a3851..6bb4f8e 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -14,7 +14,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; this.rightHand = null; } - Start() + Awake() { this.initTransforms(); } diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 1960e19..06b5ff4 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -21,7 +21,7 @@ class ShoulderTransforms extends MonoBehavior this.rightArm = null; } - Awake() + OnEnable() { if (this.leftArm === null) { From ba6dc1ab37b174a47c767c18474d5e0365c591cf Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 04:25:54 -0400 Subject: [PATCH 076/562] Component initialization debugging --- vrarmik/AvatarVRTrackingReferences.js | 2 +- vrarmik/ShoulderPoser.js | 2 +- vrarmik/VRArmIK.js | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 6bb4f8e..e60936c 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -42,7 +42,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; let t = this[k]; if (t === null) { - t = new GameObject(name).GetComponent(StaticOffsetTransform); + t = new GameObject(name).AddComponent(StaticOffsetTransform); t.transform.parent = this.transform; this.setStaticOffsetSettings(t); this[k] = t; diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 93add01..41d5911 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -10,7 +10,7 @@ class ShoulderPoser extends MonoBehavior constructor(...args) { super(...args); - this.shoulder = new GameObject().GetComponent(ShoulderTransforms); + this.shoulder = this.GetComponent(ShoulderTransforms); this.vrTrackingReferences = null; this.avatarTrackingReferences = null; diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 24baeed..667cf6e 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -68,7 +68,7 @@ class HandSettings constructor(...args) { super(...args); - this.arm = new GameObject().GetComponent(ArmTransforms); + this.arm = new GameObject().AddComponent(ArmTransforms); this.shoulder = null; this.shoulderPoser = null; this.target = new Transform(); From 35e15686ff9b91699d0979c5da06ce7e6d93298b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 04:26:26 -0400 Subject: [PATCH 077/562] Add missing Unity euler angle methods --- vrarmik/VRArmIK.js | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 667cf6e..fb661cd 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -63,6 +63,19 @@ class HandSettings } } +function toSignedEulerAngle(n) +{ + let result = toPositiveEulerAngle(n); + if (result > 180) + result = result - 360; + return result; +} +function toPositiveEulerAngle(n) +{ + const result = (n % 360 + 360) % 360; + return result; +} + class VRArmIK extends MonoBehavior { constructor(...args) { From 78230d874a21e2d0e29aca536722d16059c56ea3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 04:27:11 -0400 Subject: [PATCH 078/562] More major Unity debugging --- vrarmik/ArmTransforms.js | 14 ++-- vrarmik/ShoulderPoser.js | 50 +++++++------- vrarmik/StaticOffsetTransform.js | 20 +++--- vrarmik/VRArmIK.js | 113 +++++++++++++++---------------- 4 files changed, 97 insertions(+), 100 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 89883ba..c7891c7 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -18,17 +18,17 @@ class ArmTransforms extends MonoBehavior } get upperArmLength() { - return distance(this.upperArm, this.lowerArm); + return this.distance(this.upperArm, this.lowerArm); } get lowerArmLength() { - return distance(this.lowerArm, this.hand); + return this.distance(this.lowerArm, this.hand); } get armLength() { return this.upperArmLength + this.lowerArmLength; } distance(a, b) { - return (a.position - b.position).magnitude; + return a.position.distanceTo(b.position); } Start() @@ -39,7 +39,7 @@ class ArmTransforms extends MonoBehavior updateArmLengths() { - const shoulderWidth = (this.upperArm.position - this.lowerArm.position).magnitude; + const shoulderWidth = new Vector3().subVectors(this.upperArm.position, this.lowerArm.position).magnitude; const _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2; this.setArmLength(_armLength); } @@ -50,7 +50,7 @@ class ArmTransforms extends MonoBehavior { const oldLowerArmLength = distance(this.lowerArm, this.hand); - let newScale = this.upperArm.localScale - Vector3.Scale(this.upperArm.localScale, this.scaleAxis).magnitude * this.scaleAxis; + let newScale = new Vector3().subVectors(this.upperArm.localScale, this.scaleAxis.clone().multiplyScalar(Vector3.Scale(this.upperArm.localScale, this.scaleAxis).magnitude)); const scaleFactor = Vector3.Scale(this.upperArm.localScale, this.scaleAxis).magnitude / upperArmLength * length; newScale += this.scaleAxis * scaleFactor; this.upperArm.localScale = newScale; @@ -83,8 +83,8 @@ class ArmTransforms extends MonoBehavior const upperArmFactor = .48; if (this.armLengthByScale) { - this.upperArm.localScale = this.upperArm.localScale / this.armLength * length; - this.hand.localScale = Vector3.one / (1 - (1 - this.scaleHandFactor) * (1 - this.upperArm.localScale.x)); + this.upperArm.localScale = this.upperArm.localScale.clone().divideScalar(this.armLength).multiplyScalar(length); + this.hand.localScale = Vector3.one.divideScalar(1 - (1 - this.scaleHandFactor) * (1 - this.upperArm.localScale.x)); } else { diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 41d5911..827fe20 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -105,14 +105,14 @@ class ShoulderPoser extends MonoBehavior rotateLeftShoulder() { - this.rotateShoulderUp(shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand.transform, + this.rotateShoulderUp(this.shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand.transform, this.leftShoulderAnkerStartLocalPosition, 1); } rotateRightShoulder() { - this.rotateShoulderUp(shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand.transform, + this.rotateShoulderUp(this.shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand.transform, this.rightShoulderAnkerStartLocalPosition, -1); } @@ -120,7 +120,7 @@ class ShoulderPoser extends MonoBehavior initialShoulderLocalPos, angleSign) { const initialShoulderPos = this.shoulder.transform.TransformPoint(initialShoulderLocalPos); - const handShoulderOffset = targetHand.position - this.initialShoulderPos; + const handShoulderOffset = new Vector3().subVectors(targetHand.position, this.initialShoulderPos); const armLength = arm.armLength; const targetAngle = Vector3.zero; @@ -147,15 +147,15 @@ class ShoulderPoser extends MonoBehavior positionShoulder() { - const headNeckOffset = this.avatarTrackingReferences.hmd.transform.rotation * this.headNeckDirectionVector; - const targetPosition = this.avatarTrackingReferences.head.transform.position + headNeckOffset * this.headNeckDistance; + const headNeckOffset = this.headNeckDirectionVector.clone().applyQuaternion(this.avatarTrackingReferences.hmd.transform.rotation); + const targetPosition = new Vector3().addVectors(this.avatarTrackingReferences.head.transform.position, headNeckOffset.clone().multiplyScalar(this.headNeckDistance)); this.shoulder.transform.localPosition = - this.shoulder.transform.parent.InverseTransformPoint(targetPosition) + this.neckShoulderDistance; + new Vector3().addVectors(this.shoulder.transform.parent.InverseTransformPoint(targetPosition), this.neckShoulderDistance); } rotateShoulderUp() { - const angle = getCombinedDirectionAngleUp(); + const angle = this.getCombinedDirectionAngleUp(); const targetRotation = new Vector3(0, angle, 0); @@ -169,12 +169,13 @@ class ShoulderPoser extends MonoBehavior this.clampHeadRotationDeltaUp(targetRotation); } - shouldthis.er.transform.eulerAngles = targetRotation; + this.shoulder.transform.eulerAngles = targetRotation; } rotateShoulderRight() { - const heightDiff = this.vrTrackingReferences.hmd.transform.position.y - PoseManager.Instance.vrSystemOffsetHeight; + + const heightDiff = this.vrTrackingReferences.hmd.position.y - PoseManager.Instance.vrSystemOffsetHeight; const relativeHeightDiff = -heightDiff / PoseManager.Instance.playerHeightHmd; const headRightRotation = VectorHelpers.getAngleBetween(this.shoulder.transform.forward, @@ -189,15 +190,15 @@ class ShoulderPoser extends MonoBehavior const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right); - this.shoulder.transform.rotation = deltaRot * this.shoulder.transform.rotation; + this.shoulder.transform.rotation = new Quaternion().multiplyQuaternions(deltaRot, this.shoulder.transform.rotation); this.positionShoulderRelative(); } positionShoulderRelative() { const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right); - const shoulderHeadDiff = this.shoulder.transform.position - this.avatarTrackingReferences.head.transform.position; - this.shoulder.transform.position = deltaRot * shoulderHeadDiff + this.avatarTrackingReferences.head.transform.position; + const shoulderHeadDiff = new Vector3().subVectors(this.shoulder.transform.position, this.avatarTrackingReferences.head.transform.position); + this.shoulder.transform.position = new Vector3().addVectors(shoulderHeadDiff.clone().applyQuaternion(deltaRot), this.avatarTrackingReferences.head.transform.position); } getCombinedDirectionAngleUp() @@ -205,19 +206,19 @@ class ShoulderPoser extends MonoBehavior const leftHand = this.avatarTrackingReferences.leftHand.transform; const rightHand = this.avatarTrackingReferences.rightHand.transform; - const distanceLeftHand = leftHand.position - this.shoulder.transform.position; - const distanceRightHand = rightHand.position - this.shoulder.transform.position; + const distanceLeftHand = new Vector3().subVectors(leftHand.position, this.shoulder.transform.position); + const distanceRightHand = new Vector3().subVectors(rightHand.position, this.shoulder.transform.position); if (this.ignoreYPos) { - this.distanceLeftHand.y = 0; - this.distanceRightHand.y = 0; + distanceLeftHand.y = 0; + distanceRightHand.y = 0; } const directionLeftHand = distanceLeftHand.normalized; const directionRightHand = distanceRightHand.normalized; - const combinedDirection = directionLeftHand + directionRightHand; + const combinedDirection = new Vector3().addVectors(directionLeftHand, directionRightHand); return Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180 / Mathf.PI; } @@ -263,8 +264,8 @@ class ShoulderPoser extends MonoBehavior clampShoulderHandDistance() { - const leftHandVector = this.avatarTrackingReferences.leftHand.transform.position - this.shoulder.leftShoulderAnchor.position; - const rightHandVector = this.avatarTrackingReferences.rightHand.transform.position - this.shoulder.rightShoulderAnchor.position; + const leftHandVector = new Vector3().subVectors(this.avatarTrackingReferences.leftHand.transform.position, this.shoulder.leftShoulderAnchor.position); + const rightHandVector = new Vector3().subVectors(this.avatarTrackingReferences.rightHand.transform.position, this.shoulder.rightShoulderAnchor.position); const leftShoulderHandDistance = leftHandVector.magnitude; const rightShoulderHandDistance = rightHandVector.magnitude; this.shoulderDislocated = false; @@ -274,9 +275,8 @@ class ShoulderPoser extends MonoBehavior if (leftShoulderHandDistance > this.shoulder.leftArm.armLength * startBeforeFactor) { this.shoulderDislocated = true; - this.shoulder.leftArm.transform.position = this.shoulder.leftShoulderAnchor.position + - leftHandVector.normalized * - (leftShoulderHandDistance - this.shoulder.leftArm.armLength * startBeforeFactor); + this.shoulder.leftArm.transform.position = new Vector3().addVectors(this.shoulder.leftShoulderAnchor.position, + leftHandVector.normalized.multiplyScalar(leftShoulderHandDistance - this.shoulder.leftArm.armLength * startBeforeFactor)); } else { @@ -286,10 +286,8 @@ class ShoulderPoser extends MonoBehavior if (rightShoulderHandDistance > this.shoulder.rightArm.armLength * this.startBeforeFactor) { this.shoulderDislocated = true; - this.shoulder.rightArm.transform.position = this.shoulder.rightShoulderAnchor.position + - rightHandVector.normalized * - (rightShoulderHandDistance - - this.shoulder.rightArm.armLength * startBeforeFactor); + this.shoulder.rightArm.transform.position = new Vector3().addVectors(this.shoulder.rightShoulderAnchor.position, + rightHandVector.normalized.multiplyScalar(rightShoulderHandDistance - this.shoulder.rightArm.armLength * startBeforeFactor)); } else { diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index eb59320..cd54812 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -68,27 +68,27 @@ class StaticOffsetTransform extends MonoBehavior if (this.reference === null) return; - const rot = this.switchAxis(this.referenceLocalRotation ? this.reference.localEulerAngles : this.reference.eulerAngles, this.axisOrder) + - this.offsetRotation; - rot.Scale(referenceRotationMultiplicator); + const rot = new Vector3().addVectors(this.switchAxis(this.referenceLocalRotation ? this.reference.localEulerAngles : this.reference.eulerAngles, this.axisOrder), + this.offsetRotation); + rot.multiply(this.referenceRotationMultiplicator); const pos = this.referenceLocalPosition ? this.reference.localPosition : this.reference.position; if (this.applyForwardOffsetAfterRotationOffset) { - pos += Quaternion.Euler(rot) * Vector3.right * this.orientationalOffset.x; - pos += Quaternion.Euler(rot) * Vector3.up * othis.rientationalOffset.y; - pos += Quaternion.Euler(rot) * Vector3.forward * this.orientationalOffset.z; + pos.add(Vector3.right.applyQuaternion(Quaternion.Euler(rot)).multiplyScalar(this.orientationalOffset.x)); + pos.add(Vector3.up.applyQuaternion(Quaternion.Euler(rot)).multiplyScalar(this.orientationalOffset.y)); + pos.add(Vector3.forward.applyQuaternion(Quaternion.Euler(rot)).multiplyScalar(this.orientationalOffset.z)); } else { - pos += this.reference.right * this.orientationalOffset.x; - pos += this.reference.up * this.orientationalOffset.y; - pos += this.reference.forward * this.orientationalOffset.z; + pos.add(this.reference.right.multiplyScalar(this.orientationalOffset.x)); + pos.add(this.reference.up.multiplyScalar(this.orientationalOffset.y)); + pos.add(this.reference.forward.multiplyScalar(this.orientationalOffset.z)); } - pos += offsetPosition; + pos.add(this.offsetPosition); if (this.applyPosition) { diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index fb661cd..f9b71a9 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -155,7 +155,7 @@ function toPositiveEulerAngle(n) calcElbowInnerAngle() { const eulerAngles = new Vector3(); - const targetShoulderDistance = (this.target.position - this.upperArmPos).magnitude; + const targetShoulderDistance = new Vector3().subVectors(this.target.position, this.upperArmPos).magnitude; let innerAngle; if (targetShoulderDistance > this.arm.armLength) @@ -184,8 +184,8 @@ function toPositiveEulerAngle(n) rotateShoulder() { const eulerAngles = new Vector3(); - const targetShoulderDirection = (target.position - upperArmPos).normalized; - const targetShoulderDistance = (target.position - upperArmPos).magnitude; + const targetShoulderDirection = new Vector3().subVectors(this.target.position, this.upperArmPos).normalized; + const targetShoulderDistance = new Vector3().subVectors(this.target.position, this.upperArmPos).magnitude; eulerAngles.y = (this.left ? -1 : 1) * Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(this.arm.upperArmLength, 2) - @@ -193,16 +193,15 @@ function toPositiveEulerAngle(n) if (isNaN(eulerAngles.y)) eulerAngles.y = 0; - const shoulderRightRotation = Quaternion.FromToRotation(this.armDirection, targetShoulderDirection); this.setUpperArmRotation(shoulderRightRotation); - this.arm.upperArm.rotation = Quaternion.AngleAxis(eulerAngles.y, lowerArmRotation * Vector3.up) * this.arm.upperArm.rotation; + this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(eulerAngles.y, new Vector3().multiplyVectors(this.lowerArmRotation, Vector3.up)), this.arm.upperArm.rotation); this.setLowerArmLocalRotation(Quaternion.Euler(this.nextLowerArmAngle)); } getElbowTargetAngle() { - const localHandPosNormalized = this.shoulderAnker.InverseTransformPoint(this.handPos) / this.arm.armLength; + const localHandPosNormalized = this.shoulderAnker.InverseTransformPoint(this.handPos).divideScalar(this.arm.armLength); // angle from Y let angle = this.elbowSettings.yWeight * localHandPosNormalized.y + this.elbowSettings.offsetAngle; @@ -243,9 +242,9 @@ function toPositiveEulerAngle(n) correctElbowRotation() { - const s = beforePositioningSettings; + const s = this.beforePositioningSettings; - const localTargetPos = this.shoulderAnker.InverseTransformPoint(target.position) / arm.armLength; + const localTargetPos = this.shoulderAnker.InverseTransformPoint(this.target.position).divideScalar(this.arm.armLength); const elbowOutsideFactor = Mathf.Clamp01( Mathf.Clamp01((s.startBelowZ - localTargetPos.z) / Mathf.Abs(s.startBelowZ) * .5) * @@ -254,16 +253,16 @@ function toPositiveEulerAngle(n) Mathf.Clamp01(1 - localTargetPos.x * (this.left ? -1 : 1)) ) * s.weight; - const shoulderHandDirection = (this.upperArmPos - this.handPos).normalized; - const targetDir = this.shoulder.transform.rotation * (Vector3.up + (s.correctElbowOutside ? (this.armDirection + Vector3.forward * -.2) * elbowOutsideFactor : Vector3.zero)); + const shoulderHandDirection = new Vector3().subVectors(this.upperArmPos, this.handPos).normalized; + const targetDir = new Vector3().addVectors(Vector3.up, (s.correctElbowOutside ? new Vector3().addVectors(this.armDirection, Vector3.forward.multiplyScalar(-.2)) * elbowOutsideFactor : Vector3.zero)).applyQuaternion(this.shoulder.transform.rotation); const cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000); - const upperArmUp = upperArmRotation * Vector3.up; + const upperArmUp = new Vector3().multiplyVectors(this.upperArmRotation, Vector3.up); const elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); const elbowAngle = Vector3.Angle(cross, upperArmUp) + (this.left ? 0 : 180); const rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); - this.arm.upperArm.rotation = rotation * this.arm.upperArm.rotation; + this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.arm.upperArm.rotation); } /// @@ -272,39 +271,39 @@ function toPositiveEulerAngle(n) correctElbowAfterPositioning() { const s = this.elbowCorrectionSettings; - const localTargetPos = this.shoulderAnker.InverseTransformPoint(this.target.position) / this.arm.armLength; - const shoulderHandDirection = (this.upperArmPos - this.handPos).normalized; + const localTargetPos = this.shoulderAnker.InverseTransformPoint(this.target.position).divideScalar(this.arm.armLength); + const shoulderHandDirection = new Vector3().subVectors(this.upperArmPos, this.handPos).normalized; const elbowPos = s.localElbowPos; if (this.left) elbowPos.x *= -1; - const targetDir = this.shoulder.transform.rotation * elbowPos.normalized; + const targetDir = elbowPos.normalized.applyQuaternion(this.shoulder.transform.rotation); const cross = Vector3.Cross(shoulderHandDirection, targetDir); - const upperArmUp = this.upperArmRotation * Vector3.up; + const upperArmUp = new Vector3().multiplyVectors(this.upperArmRotation, Vector3.up); - let distance = this.target.position - this.upperArmPos; - distance = distance.magnitude * this.shoulder.transform.InverseTransformDirection(distance / distance.magnitude); + let distance = new Vector3().subVectors(this.target.position, this.upperArmPos); + distance = this.shoulder.transform.InverseTransformDirection(distance.clone().divideScalar(distance.magnitude)).multiplyScalar(distance.magnitude); - const weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / arm.armLength) / + const weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / this.arm.armLength) / s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1) * 3)) * Mathf.Clamp01((s.startBelowY - localTargetPos.y) / s.startBelowY); const elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); const elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (this.left ? 0 : 180); - const rotation = Quaternion.AngleAxis((elbowAngle2 * Mathf.Sign(elbowTargetUp)).toSignedEulerAngle() * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); - this.arm.upperArm.rotation = rotation * this.arm.upperArm.rotation; + const rotation = Quaternion.AngleAxis(toSignedEulerAngle(elbowAngle2 * Mathf.Sign(elbowTargetUp)) * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); + this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.arm.upperArm.rotation); } rotateElbow(angle) { - const shoulderHandDirection = (this.upperArmPos - this.handPos).normalized; + const shoulderHandDirection = new Vector3().subVectors(this.upperArmPos, this.handPos).normalized; const rotation = Quaternion.AngleAxis(angle, shoulderHandDirection); - this.setUpperArmRotation(rotation * this.upperArmRotation); + this.setUpperArmRotation(new Quaternion().multiplyQuaternions(rotation, this.upperArmRotation)); } //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp @@ -318,16 +317,16 @@ function toPositiveEulerAngle(n) rotateElbowWithHandRight() { const s = this.handSettings; - let handUpVec = this.target.rotation * Vector3.up; - const forwardAngle = VectorHelpers.getAngleBetween(lowerArmRotation * Vector3.right, this.target.rotation * Vector3.right, - lowerArmRotation * Vector3.up, lowerArmRotation * Vector3.forward); + let handUpVec = Vector3.up.applyQuaternion(this.target.rotation); + const forwardAngle = VectorHelpers.getAngleBetween(Vector3.right.applyQuaternion(this.lowerArmRotation), Vector3.right.applyQuaternion(this.target.rotation), + Vector3.up.applyQuaternion(this.lowerArmRotation), Vector3.forward.applyQuaternion(this.lowerArmRotation)); // todo reduce influence if hand local forward rotation is high (hand tilted inside) - const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, lowerArmRotation * Vector3.forward); - handUpVec = handForwardRotation * handUpVec; + const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, this.lowerArmRotation * Vector3.forward); + handUpVec = handUpVec.applyQuaternion(handForwardRotation); - const elbowTargetAngle = VectorHelpers.getAngleBetween(this.lowerArmRotation * Vector3.up, handUpVec, - this.lowerArmRotation * Vector3.forward, this.lowerArmRotation * this.armDirection); + const elbowTargetAngle = VectorHelpers.getAngleBetween(Vector3.up.applyQuaternion(this.lowerArmRotation), handUpVec, + Vector3.forward.applyQuaternion(this.lowerArmRotation), this.armDirection.clone().applyQuaternion(this.lowerArmRotation)); let deltaElbow = (elbowTargetAngle + (this.left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180; @@ -340,10 +339,10 @@ function toPositiveEulerAngle(n) rotateElbowWithHandFoward() { const s = this.handSettings; - const handRightVec = this.target.rotation * this.armDirection; + const handRightVec = this.armDirection.clone().applyQuaternion(this.target.rotation); - const elbowTargetAngleForward = VectorHelpers.getAngleBetween(this.lowerArmRotation * armDirection, handRightVec, - this.lowerArmRotation * Vector3.up, this.lowerArmRotation * Vector3.forward); + const elbowTargetAngleForward = VectorHelpers.getAngleBetween(this.armDirection.clone().applyQuaternion(this.lowerArmRotation), handRightVec, + Vector3.up.applyQuaternion(this.lowerArmRotation), Vector3.forward.applyQuaternion(this.lowerArmRotation)); let deltaElbowForward = (elbowTargetAngleForward + (this.left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180; @@ -357,7 +356,7 @@ function toPositiveEulerAngle(n) deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180; this.interpolatedDeltaElbowForward = Mathf.LerpAngle(this.interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); - const signedInterpolated = this.interpolatedDeltaElbowForward.toSignedEulerAngle(); + const signedInterpolated = toSignedEulerAngle(this.interpolatedDeltaElbowForward); this.rotateElbow(signedInterpolated * s.handDeltaForwardFactor); } @@ -365,28 +364,28 @@ function toPositiveEulerAngle(n) { if (this.handSettings.useWristRotation) { - let handUpVec = this.target.rotation * Vector3.up; - const forwardAngle = VectorHelpers.getAngleBetween(this.lowerArmRotation * Vector3.right, target.rotation * Vector3.right, - this.lowerArmRotation * Vector3.up, this.lowerArmRotation * Vector3.forward); + let handUpVec = Vector3.up.applyQuaternion(this.target.rotation); + const forwardAngle = VectorHelpers.getAngleBetween(Vector3.right.applyQuaternion(this.lowerArmRotation), Vector3.right.applyQuaternion(this.target.rotation), + Vector3.up.applyQuaternion(this.lowerArmRotation), Vector3.forward.applyQuaternion(this.lowerArmRotation)); // todo reduce influence if hand local forward rotation is high (hand tilted inside) - const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, this.lowerArmRotation * Vector3.forward); - handUpVec = handForwardRotation * handUpVec; + const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, Vector3.forward.applyQuaternion(this.lowerArmRotation)); + handUpVec = handUpVec.applyQuaternion(handForwardRotation); - let elbowTargetAngle = VectorHelpers.getAngleBetween(this.lowerArmRotation * Vector3.up, handUpVec, - this.lowerArmRotation * Vector3.forward, this.lowerArmRotation * this.armDirection); + let elbowTargetAngle = VectorHelpers.getAngleBetween(Vector3.up.applyQuaternion(this.lowerArmRotation), handUpVec, + Vector3.forward.applyQuaternion(this.lowerArmRotation), this.armDirection.clone().applyQuaternion(this.lowerArmRotation)); elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90, 90); - if (arm.wrist1 != null) - this.setWrist1Rotation(Quaternion.AngleAxis(elbowTargetAngle * .3, this.lowerArmRotation * this.armDirection) * this.lowerArmRotation); - if (arm.wrist2 != null) - this.setWrist2Rotation(Quaternion.AngleAxis(elbowTargetAngle * .8, this.lowerArmRotation * this.armDirection) * this.lowerArmRotation); + if (this.arm.wrist1 !== null) + this.setWrist1Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .3, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); + if (this.arm.wrist2 !== null) + this.setWrist2Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .8, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); } - this.setHandRotation(target.rotation); + this.setHandRotation(this.target.rotation); } removeShoulderRightRotation(direction) { - return Quaternion.AngleAxis(-this.shoulderPoser.shoulderRightRotation, this.shoulder.transform.right) * this.direction; + return this.direction.clone().applyQuaternion(Quaternion.AngleAxis(-this.shoulderPoser.shoulderRightRotation, this.shoulder.transform.right)); } get armDirection() { @@ -406,35 +405,35 @@ function toPositiveEulerAngle(n) } get upperArmRotation() { - return this.arm.upperArm.rotation * Quaternion.Inverse(this.upperArmStartRotation); + return new Quaternion().multiplyQuaternions(this.arm.upperArm.rotation, Quaternion.Inverse(this.upperArmStartRotation)); } get lowerArmRotation() { - return this.arm.lowerArm.rotation * Quaternion.Inverse(this.lowerArmStartRotation); + return new Quaternion().multiplyQuaternions(this.arm.lowerArm.rotation, Quaternion.Inverse(this.lowerArmStartRotation)); } get handRotation() { - return this.arm.hand.rotation * Quaternion.Inverse(this.handStartRotation); + return new Quaternion().multiplyQuaternions(this.arm.hand.rotation, Quaternion.Inverse(this.handStartRotation)); } setUpperArmRotation(rotation) { - return this.arm.upperArm.rotation = rotation * this.upperArmStartRotation; + return this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.upperArmStartRotation); } setLowerArmRotation(rotation) { - return this.arm.lowerArm.rotation = rotation * this.lowerArmStartRotation; + return this.arm.lowerArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.lowerArmStartRotation); } setLowerArmLocalRotation(rotation) { - return this.arm.lowerArm.rotation = this.upperArmRotation * rotation * this.lowerArmStartRotation; + return this.arm.lowerArm.rotation = new Quaternion().multiplyQuaternions(new Quaternion().multiplyQuaternions(this.upperArmRotation, rotation), this.lowerArmStartRotation); } setWrist1Rotation(rotation) { - return this.arm.wrist1.rotation = rotation * this.wristStartRotation; + return this.arm.wrist1.rotation = new Quaternion().multiplyQuaternions(rotation, this.wristStartRotation); } setWrist2Rotation(rotation) { - return this.arm.wrist2.rotation = rotation * this.wristStartRotation; + return this.arm.wrist2.rotation = new Quaternion().multiplyQuaternions(rotation, this.wristStartRotation); } setWristLocalRotation(rotation) { - return this.arm.wrist1.rotation = this.arm.lowerArm.rotation * rotation * this.wristStartRotation; + return this.arm.wrist1.rotation = new Quaternion().multiplyQuaternions(new Quaternion().multiplyQuaternions(this.arm.lowerArm.rotation, rotation), this.wristStartRotation); } setHandRotation(rotation) { - return this.arm.hand.rotation = this.arm.hand.rotation = rotation * this.handStartRotation; + return this.arm.hand.rotation = /* this.arm.hand.rotation = */ new Quaternion().multiplyQuaternions(rotation, this.handStartRotation); } } From c6052a33f9917b2ab9643a2f4429bf2288a3b66e Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 23:50:11 -0400 Subject: [PATCH 079/562] Small spacing cleanup --- vrarmik/AvatarVRTrackingReferences.js | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index e60936c..de5a758 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -77,12 +77,8 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; this.head.reference = this.head.reference !== null ? this.head.reference : PoseManager.Instance.vrTransforms.head; this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : PoseManager.Instance.vrTransforms.hmd; - this.leftHand.reference = this.leftHand.reference !== null - ? this.leftHand.reference - : PoseManager.Instance.vrTransforms.leftHand; - this.rightHand.reference = this.rightHand.reference !== null - ? this.rightHand.reference - : PoseManager.Instance.vrTransforms.rightHand; + this.leftHand.reference = this.leftHand.reference !== null ? this.leftHand.reference : PoseManager.Instance.vrTransforms.leftHand; + this.rightHand.reference = this.rightHand.reference !== null ? this.rightHand.reference : PoseManager.Instance.vrTransforms.rightHand; } } From 476877d57c40bf97676463b132de7dbeb7d1b43f Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 23:50:43 -0400 Subject: [PATCH 080/562] Dead code cleanup --- vrarmik/ShoulderPoser.js | 1 - 1 file changed, 1 deletion(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 827fe20..9031d57 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,7 +1,6 @@ import {Vector3, Quaternion, GameObject, MonoBehavior, Mathf} from './Unity.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import VRTrackingReferences from './VRTrackingReferences.js'; -import AvatarVRTrackingReferences from './AvatarVRTrackingReferences.js'; import PoseManager from './PoseManager.js'; import VectorHelpers from './Utils/VectorHelpers.js'; From f470a7137d80a7df05bb64863bb4c86b40a238b4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 23:52:15 -0400 Subject: [PATCH 081/562] Bugfix transforms propagation --- vrarmik/AvatarVRTrackingReferences.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index de5a758..eea7fd6 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -43,7 +43,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; if (t === null) { t = new GameObject(name).AddComponent(StaticOffsetTransform); - t.transform.parent = this.transform; + this.transform.AddChild(t.transform); this.setStaticOffsetSettings(t); this[k] = t; } @@ -55,7 +55,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; { t = new GameObject(name).transform; t.transform.localPosition = Vector3.zero; - t.transform.parent = parent; + this.transform.AddChild(t.transform); } } */ From 5319ebf1dcd5bab52a7df9a53ad09896b4a0fc48 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 23:52:48 -0400 Subject: [PATCH 082/562] Bugfix unity shoulder/shoulder base methods ambiguity --- vrarmik/ShoulderPoser.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 9031d57..6f7f1ee 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -80,8 +80,8 @@ class ShoulderPoser extends MonoBehavior { this.shoulder.transform.rotation = Quaternion.identity; this.positionShoulder(); - this.rotateShoulderUp(); - this.rotateShoulderRight(); + this.rotateShoulderUpBase(); + this.rotateShoulderRightBase(); if (this.enableDistinctShoulderRotation) { @@ -152,7 +152,7 @@ class ShoulderPoser extends MonoBehavior new Vector3().addVectors(this.shoulder.transform.parent.InverseTransformPoint(targetPosition), this.neckShoulderDistance); } - rotateShoulderUp() + rotateShoulderUpBase() { const angle = this.getCombinedDirectionAngleUp(); @@ -171,7 +171,7 @@ class ShoulderPoser extends MonoBehavior this.shoulder.transform.eulerAngles = targetRotation; } - rotateShoulderRight() + rotateShoulderRightBase() { const heightDiff = this.vrTrackingReferences.hmd.position.y - PoseManager.Instance.vrSystemOffsetHeight; From 86c5b57efd4849c1a640879c2547c3bd7b769985 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 14 Oct 2019 23:59:02 -0400 Subject: [PATCH 083/562] References bugfixing --- vrarmik/ShoulderPoser.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 6f7f1ee..a8dc7d5 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -119,7 +119,7 @@ class ShoulderPoser extends MonoBehavior initialShoulderLocalPos, angleSign) { const initialShoulderPos = this.shoulder.transform.TransformPoint(initialShoulderLocalPos); - const handShoulderOffset = new Vector3().subVectors(targetHand.position, this.initialShoulderPos); + const handShoulderOffset = new Vector3().subVectors(targetHand.position, initialShoulderPos); const armLength = arm.armLength; const targetAngle = Vector3.zero; @@ -137,8 +137,8 @@ class ShoulderPoser extends MonoBehavior -this.distinctShoulderRotationLimitBackward, 0); } - targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5) * distinctShoulderRotationMultiplier, - -distinctShoulderRotationLimitUpward, 0); + targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, + -this.distinctShoulderRotationLimitUpward, 0); shoulderSide.localEulerAngles = targetAngle * angleSign; } From 448eadd4f0e31a90c1368b7d11e5f33f70c72098 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 15 Oct 2019 00:00:35 -0400 Subject: [PATCH 084/562] Arm transforms debugging --- vrarmik/ArmTransforms.js | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index c7891c7..5628e74 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,4 +1,4 @@ -import {Vector3, Transform, MonoBehavior, Mathf} from './Unity.js'; +import {Vector3, Quaternion, Transform, MonoBehavior, Mathf} from './Unity.js'; import PoseManager from './PoseManager.js'; class ArmTransforms extends MonoBehavior @@ -7,10 +7,19 @@ class ArmTransforms extends MonoBehavior super(...args); this.upperArm = new Transform(); + this.upperArm.localPosition = new Vector3(0, 0, 0); this.lowerArm = new Transform(); + this.lowerArm.localPosition = new Vector3(-0.3, 0, 0); this.wrist1 = new Transform(); this.wrist2 = new Transform(); this.hand = new Transform(); + this.hand.localPosition = new Vector3(-0.3, 0, 0); + + this.transform.AddChild(this.upperArm); + this.upperArm.AddChild(this.lowerArm); + // this.lowerArm.AddChild(this.wrist1); + // this.lowerArm.AddChild(this.wrist2); + this.lowerArm.AddChild(this.hand); this.armLengthByScale = false; this.scaleAxis = Vector3.one; From abadabed98261a9834eb055083f2a16e205c7c69 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 15 Oct 2019 00:06:15 -0400 Subject: [PATCH 085/562] Bugfix shoulder transforms --- vrarmik/ShoulderTransforms.js | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 06b5ff4..222dbd2 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -11,33 +11,46 @@ class ShoulderTransforms extends MonoBehavior super(...args); this.leftShoulder = new Transform(); + this.transform.AddChild(this.leftShoulder); this.rightShoulder = new Transform(); + this.transform.AddChild(this.rightShoulder); /* this.leftShoulderRenderer = new Transform(); this.rightShoulderRenderer = new Transform(); */ this.leftShoulderAnchor = new Transform(); + this.leftShoulderAnchor.localPosition = new Vector3(-0.3, 0, 0); + this.transform.AddChild(this.leftShoulderAnchor); this.rightShoulderAnchor = new Transform(); + this.rightShoulderAnchor.localPosition = new Vector3(0.3, 0, 0); + this.transform.AddChild(this.rightShoulderAnchor); this.leftArm = null; this.rightArm = null; } OnEnable() { + const shoulderPoser = this.GetComponent(ShoulderPoser); if (this.leftArm === null) { this.leftArm = new GameObject().AddComponent(ArmTransforms); const armIk = this.leftArm.GetComponentInChildren(VRArmIK); armIk.shoulder = this; - armIk.shoulderPoser = this.GetComponent(ShoulderPoser); + armIk.shoulderPoser = shoulderPoser; armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; + this.leftShoulderAnchor.AddChild(this.leftArm.transform); } if (this.rightArm === null) { this.rightArm = new GameObject().AddComponent(ArmTransforms); const armIk = this.rightArm.GetComponentInChildren(VRArmIK); armIk.shoulder = this; - armIk.shoulderPoser = this.GetComponent(ShoulderPoser); + armIk.shoulderPoser = shoulderPoser; armIk.target = armIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; + + armIk.left = false; + this.rightArm.lowerArm.localPosition = new Vector3(0.3, 0, 0); + this.rightArm.hand.localPosition = new Vector3(0.3, 0, 0); + this.rightShoulderAnchor.AddChild(this.rightArm.transform); } } From a7efc076ffde313226c833d702d20110368119a8 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 15 Oct 2019 00:10:11 -0400 Subject: [PATCH 086/562] Major Unity port debugging --- vrarmik/Unity.js | 56 +++++++++++++++++++++++++++++++++++++----------- 1 file changed, 43 insertions(+), 13 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index f0374d7..9530d44 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -1,5 +1,6 @@ const DEG2RAD = Math.PI/180; const RAD2DEG = 180/Math.PI; +const ORDER = 'ZXY'; class Vector2 extends THREE.Vector2 { get magnitude() { @@ -159,7 +160,7 @@ class Quaternion extends THREE.Quaternion { return new Quaternion().setFromUnitVectors(a, b); } static Euler(v) { - return new Quaternion().setFromEuler(new THREE.Euler(v.x, v.y, v.z, 'ZXY')); + return new Quaternion().setFromEuler(new THREE.Euler(v.x * DEG2RAD, v.y * DEG2RAD, v.z * DEG2RAD, ORDER)); } static Inverse(q) { return q.clone().inverse(); @@ -184,6 +185,7 @@ class Transform { this._localScale = new Vector3(1, 1, 1); this._localScale.bindOnchange(localChange); + this._children = []; this._parent = null; this._matrix = new THREE.Matrix4(); @@ -195,21 +197,27 @@ class Transform { return this._position.clone(); } set position(position) { + this.updateMatrixWorld(); this._position.copy(position); + this.updateLocalMatrix(); } get rotation() { this.updateMatrixWorld(); return this._rotation.clone(); } set rotation(rotation) { + this.updateMatrixWorld(); this._rotation.copy(rotation); + this.updateLocalMatrix(); } get scale() { this.updateMatrixWorld(); return this._scale.clone(); } set scale(scale) { + this.updateMatrixWorld(); this._scale.copy(scale); + this.updateLocalMatrix(); } get localPosition() { @@ -236,7 +244,7 @@ class Transform { } set parent(parent) { this._parent = parent; - this.matrixWorldNeedsUpdate = true; + this.localChange(); } get right() { @@ -249,9 +257,23 @@ class Transform { return this.TransformPoint(Vector3.forward); } + AddChild(child) { + this._children.push(child); + child.parent = this; + } + + updateLocalMatrix() { + this._matrixWorld.compose(this._position, this._rotation, this._scale); + this._matrix.copy(this._matrixWorld); + if (this._parent) { + this._matrix.premultiply(new THREE.Matrix4().getInverse(this._parent._matrixWorld)); + } + this._matrix.decompose(this._localPosition, this._localRotation, this._localScale); + this.matrixWorldNeedsUpdate = false; + } updateMatrixWorld() { if (this.matrixWorldNeedsUpdate) { - this._matrix.compose(this._position, this._rotation, this._scale); + this._matrix.compose(this._localPosition, this._localRotation, this._localScale); this._matrixWorld.copy(this._matrix); if (this._parent) { @@ -266,21 +288,24 @@ class Transform { } localChange() { this.matrixWorldNeedsUpdate = true; + for (let i = 0; i < this._children.length; i++) { + this._children[i].localChange(); + } } get eulerAngles() { - const e = new THREE.Euler().setFromQuaternion(this.rotation, 'ZXY'); - return new Vector3(e.x, e.y, e.z); + const e = new THREE.Euler().setFromQuaternion(this.rotation, ORDER); + return new Vector3(e.x * RAD2DEG, e.y * RAD2DEG, e.z * RAD2DEG); } set eulerAngles(v) { - this.rotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(v.x, v.y, v.z, 'ZXY')); + this.rotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(v.x * DEG2RAD, v.y * DEG2RAD, v.z * DEG2RAD, ORDER)); } get localEulerAngles() { - const e = new THREE.Euler().setFromQuaternion(this.localRotation, 'ZXY'); - return new Vector3(e.x, e.y, e.z); + const e = new THREE.Euler().setFromQuaternion(this.localRotation, ORDER); + return new Vector3(e.x * RAD2DEG, e.y * RAD2DEG, e.z * RAD2DEG); } set localEulerAngles(v) { - this.localRotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(v.x, v.y, v.z, 'ZXY')); + this.localRotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(v.x * DEG2RAD, v.y * DEG2RAD, v.z * DEG2RAD, ORDER)); } TransformPoint(v) { @@ -308,7 +333,6 @@ class GameObject { this.transform = new Transform(); this.components = new Map(); - this.children = []; gameObjects.push(this); } @@ -321,8 +345,7 @@ class GameObject { return component; } AddChild(child) { - this.children.push(child); - child.transform.parent = this.transform; + this.transform.AddChild(child.transform); } static startAll() { for (let i = 0; i < gameObjects.length; i++) { @@ -411,11 +434,18 @@ const Mathf = { Abs(v) { return Math.abs(v); }, + Log(a, b) { + let result = Math.log(a); + if (b !== undefined) { + result /= Math.log(b); + } + return result; + }, Lerp(a, b, t) { return a*(1-v) + b*v; }, LerpAngle(a, b, t) { - const num = Mathf.Repeat(b - a, 360); + let num = Mathf.Repeat(b - a, 360); if (num > 180) { num -= 360; } From b715562d66dd6390eee2dcf1735171d8162ffcdc Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 15 Oct 2019 00:19:25 -0400 Subject: [PATCH 087/562] VRArmIK debugging --- vrarmik/VRArmIK.js | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index f9b71a9..effb6dc 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -81,7 +81,7 @@ function toPositiveEulerAngle(n) constructor(...args) { super(...args); - this.arm = new GameObject().AddComponent(ArmTransforms); + this.arm = this.GetOrAddComponent(ArmTransforms); this.shoulder = null; this.shoulderPoser = null; this.target = new Transform(); @@ -126,6 +126,7 @@ function toPositiveEulerAngle(n) this.calcElbowInnerAngle(); this.rotateShoulder(); this.correctElbowRotation(); + if (this.elbowSettings.calcElbowAngle) { this.positionElbow(); @@ -149,7 +150,7 @@ function toPositiveEulerAngle(n) updateUpperArmPosition() { - //arm.upperArm.position = shoulderAnker.transform.position; + //this.arm.upperArm.position = this.shoulderAnker.position; } calcElbowInnerAngle() From f6f00913b66658db54ebbe43896d408cdb967290 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 15 Oct 2019 00:20:19 -0400 Subject: [PATCH 088/562] More VRArmIK debugging --- vrarmik/VRArmIK.js | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index effb6dc..2eecd6e 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -184,20 +184,21 @@ function toPositiveEulerAngle(n) //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp rotateShoulder() { - const eulerAngles = new Vector3(); - const targetShoulderDirection = new Vector3().subVectors(this.target.position, this.upperArmPos).normalized; - const targetShoulderDistance = new Vector3().subVectors(this.target.position, this.upperArmPos).magnitude; + const eulerAngles = new Vector3(); + const targetShoulderDirection = new Vector3().subVectors(this.target.position, this.upperArmPos).normalized; + const targetShoulderDistance = new Vector3().subVectors(this.target.position, this.upperArmPos).magnitude; + + eulerAngles.y = (this.left ? -1 : 1) * + Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(this.arm.upperArmLength, 2) - + Mathf.Pow(this.arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * this.arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; + if (isNaN(eulerAngles.y)) + eulerAngles.y = 0; - eulerAngles.y = (this.left ? -1 : 1) * - Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(this.arm.upperArmLength, 2) - - Mathf.Pow(this.arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * this.arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; - if (isNaN(eulerAngles.y)) - eulerAngles.y = 0; - const shoulderRightRotation = Quaternion.FromToRotation(this.armDirection, targetShoulderDirection); - this.setUpperArmRotation(shoulderRightRotation); - this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(eulerAngles.y, new Vector3().multiplyVectors(this.lowerArmRotation, Vector3.up)), this.arm.upperArm.rotation); - this.setLowerArmLocalRotation(Quaternion.Euler(this.nextLowerArmAngle)); + const shoulderRightRotation = Quaternion.FromToRotation(this.armDirection, targetShoulderDirection); + this.setUpperArmRotation(shoulderRightRotation); + this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(eulerAngles.y, Vector3.up.applyQuaternion(this.lowerArmRotation)), this.arm.upperArm.rotation); + this.setLowerArmLocalRotation(Quaternion.Euler(this.nextLowerArmAngle)); } getElbowTargetAngle() @@ -255,13 +256,13 @@ function toPositiveEulerAngle(n) ) * s.weight; const shoulderHandDirection = new Vector3().subVectors(this.upperArmPos, this.handPos).normalized; - const targetDir = new Vector3().addVectors(Vector3.up, (s.correctElbowOutside ? new Vector3().addVectors(this.armDirection, Vector3.forward.multiplyScalar(-.2)) * elbowOutsideFactor : Vector3.zero)).applyQuaternion(this.shoulder.transform.rotation); - const cross = Vector3.Cross(shoulderHandDirection, targetDir * 1000); + const targetDir = new Vector3().addVectors(Vector3.up, (s.correctElbowOutside ? new Vector3().addVectors(this.armDirection, Vector3.forward.multiplyScalar(-.2)).multiplyScalar(elbowOutsideFactor) : Vector3.zero)).applyQuaternion(this.shoulder.transform.rotation); + const cross = Vector3.Cross(shoulderHandDirection, targetDir.clone().multiplyScalar(1000)); - const upperArmUp = new Vector3().multiplyVectors(this.upperArmRotation, Vector3.up); + const upperArmUp = Vector3.up.applyQuaternion(this.upperArmRotation); const elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - const elbowAngle = Vector3.Angle(cross, upperArmUp) + (this.left ? 0 : 180); + const elbowAngle = (cross.equals(Vector3.zero) ? 0 : Vector3.Angle(cross, upperArmUp)) + (this.left ? 0 : 180); const rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.arm.upperArm.rotation); } @@ -282,7 +283,7 @@ function toPositiveEulerAngle(n) const targetDir = elbowPos.normalized.applyQuaternion(this.shoulder.transform.rotation); const cross = Vector3.Cross(shoulderHandDirection, targetDir); - const upperArmUp = new Vector3().multiplyVectors(this.upperArmRotation, Vector3.up); + const upperArmUp = Vector3.up.applyQuaternion(this.upperArmRotation); let distance = new Vector3().subVectors(this.target.position, this.upperArmPos); @@ -323,7 +324,7 @@ function toPositiveEulerAngle(n) Vector3.up.applyQuaternion(this.lowerArmRotation), Vector3.forward.applyQuaternion(this.lowerArmRotation)); // todo reduce influence if hand local forward rotation is high (hand tilted inside) - const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, this.lowerArmRotation * Vector3.forward); + const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, Vector3.forward.applyQuaternion(this.lowerArmRotation)); handUpVec = handUpVec.applyQuaternion(handForwardRotation); const elbowTargetAngle = VectorHelpers.getAngleBetween(Vector3.up.applyQuaternion(this.lowerArmRotation), handUpVec, From 0eb076eda6fd4208ca12ec4a8393ee09cb7ffd92 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 15 Oct 2019 00:23:30 -0400 Subject: [PATCH 089/562] Add vrarmik test HTML --- vrarmik.html | 176 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 vrarmik.html diff --git a/vrarmik.html b/vrarmik.html new file mode 100644 index 0000000..37576e4 --- /dev/null +++ b/vrarmik.html @@ -0,0 +1,176 @@ + + + + + + + + + From 45cfe146bc0c4ae5e108d76c180f17fdb6b78e15 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 15 Oct 2019 01:16:43 -0400 Subject: [PATCH 090/562] Extract rigging to VRArmIK --- vrarmik.html | 113 ++++++++++++++++--------------------------------- vrarmik/Rig.js | 57 +++++++++++++++++++++++++ 2 files changed, 93 insertions(+), 77 deletions(-) create mode 100644 vrarmik/Rig.js diff --git a/vrarmik.html b/vrarmik.html index 37576e4..50b4340 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -9,22 +9,7 @@ + - - From 52b46e589b138c9860b929b0722350ed6243ed85 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 18 Oct 2019 23:06:39 -0400 Subject: [PATCH 139/562] Add Reflector.js --- Reflector.js | 271 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 271 insertions(+) create mode 100644 Reflector.js diff --git a/Reflector.js b/Reflector.js new file mode 100644 index 0000000..3f9be10 --- /dev/null +++ b/Reflector.js @@ -0,0 +1,271 @@ +/** + * @author Slayvin / http://slayvin.net + */ + +THREE.Reflector = function ( geometry, options ) { + + THREE.Mesh.call( this, geometry ); + + this.type = 'Reflector'; + + var scope = this; + + options = options || {}; + + var color = ( options.color !== undefined ) ? new THREE.Color( options.color ) : new THREE.Color( 0x7F7F7F ); + var addColor = ( options.addColor !== undefined ) ? new THREE.Color( options.addColor ) : new THREE.Color( 0x000000 ); + var textureWidth = options.textureWidth || 512; + var textureHeight = options.textureHeight || 512; + var clipBias = options.clipBias || 0; + var shader = options.shader || THREE.Reflector.ReflectorShader; + var recursion = options.recursion !== undefined ? options.recursion : 0; + + // + + var reflectorPlane = new THREE.Plane(); + var normal = new THREE.Vector3(); + var reflectorWorldPosition = new THREE.Vector3(); + var cameraWorldPosition = new THREE.Vector3(); + var rotationMatrix = new THREE.Matrix4(); + var lookAtPosition = new THREE.Vector3( 0, 0, - 1 ); + var clipPlane = new THREE.Vector4(); + var viewport = new THREE.Vector4(); + + var view = new THREE.Vector3(); + var target = new THREE.Vector3(); + var q = new THREE.Vector4(); + + var textureMatrix = new THREE.Matrix4(); + var virtualCamera = new THREE.PerspectiveCamera(); + + var parameters = { + minFilter: THREE.LinearFilter, + magFilter: THREE.LinearFilter, + format: THREE.RGBFormat, + stencilBuffer: false + }; + + var renderTarget = new THREE.WebGLRenderTarget( textureWidth, textureHeight, parameters ); + + if ( ! THREE.Math.isPowerOfTwo( textureWidth ) || ! THREE.Math.isPowerOfTwo( textureHeight ) ) { + + renderTarget.texture.generateMipmaps = false; + + } + + var material = new THREE.ShaderMaterial( { + uniforms: THREE.UniformsUtils.clone( shader.uniforms ), + fragmentShader: shader.fragmentShader, + vertexShader: shader.vertexShader + } ); + + material.uniforms.tDiffuse.value = renderTarget.texture; + material.uniforms.color.value = color; + material.uniforms.addColor.value = addColor; + material.uniforms.textureMatrix.value = textureMatrix; + + this.material = material; + this.renderOrder = - Infinity; // render first + + this.onBeforeRender = function ( renderer, scene, camera ) { + + if ( 'recursion' in camera.userData ) { + + if ( camera.userData.recursion === recursion ) return; + + camera.userData.recursion ++; + + } + + reflectorWorldPosition.setFromMatrixPosition( scope.matrixWorld ); + cameraWorldPosition.setFromMatrixPosition( camera.matrixWorld ); + + rotationMatrix.extractRotation( scope.matrixWorld ); + + normal.set( 0, 0, -1 ); + normal.applyMatrix4( rotationMatrix ); + + view.subVectors( reflectorWorldPosition, cameraWorldPosition ); + + // Avoid rendering when reflector is facing away + + if ( view.dot( normal ) < 0 ) return; + + view.copy(cameraWorldPosition); + + rotationMatrix.extractRotation( camera.matrixWorld ); + + lookAtPosition.set( 0, 0, - 1 ); + lookAtPosition.applyMatrix4( rotationMatrix ); + lookAtPosition.add( cameraWorldPosition ); + + target.subVectors( reflectorWorldPosition, lookAtPosition ); + target.reflect( normal ).negate(); + target.add( reflectorWorldPosition ); + + virtualCamera.position.copy( view ); + virtualCamera.up.set( 0, 1, 0 ); + virtualCamera.up.applyMatrix4( rotationMatrix ); + virtualCamera.up.reflect( normal ); + virtualCamera.lookAt( target ); + + virtualCamera.far = camera.far; // Used in WebGLBackground + + virtualCamera.updateMatrixWorld(); + virtualCamera.projectionMatrix.copy( camera.projectionMatrix ); + + virtualCamera.userData.recursion = 0; + + // Update the texture matrix + textureMatrix.set( + 0.5, 0.0, 0.0, 0.5, + 0.0, 0.5, 0.0, 0.5, + 0.0, 0.0, 0.5, 0.5, + 0.0, 0.0, 0.0, 1.0 + ); + textureMatrix.multiply( virtualCamera.projectionMatrix ); + textureMatrix.multiply( virtualCamera.matrixWorldInverse ); + textureMatrix.multiply( scope.matrixWorld ); + + // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html + // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf + reflectorPlane.setFromNormalAndCoplanarPoint( normal, reflectorWorldPosition ); + reflectorPlane.applyMatrix4( virtualCamera.matrixWorldInverse ); + + clipPlane.set( reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant ); + + var projectionMatrix = virtualCamera.projectionMatrix; + + q.x = ( Math.sign( clipPlane.x ) + projectionMatrix.elements[ 8 ] ) / projectionMatrix.elements[ 0 ]; + q.y = ( Math.sign( clipPlane.y ) + projectionMatrix.elements[ 9 ] ) / projectionMatrix.elements[ 5 ]; + q.z = - 1.0; + q.w = ( 1.0 + projectionMatrix.elements[ 10 ] ) / projectionMatrix.elements[ 14 ]; + + // Calculate the scaled plane vector + clipPlane.multiplyScalar( 2.0 / clipPlane.dot( q ) ); + + // Replacing the third row of the projection matrix + projectionMatrix.elements[ 2 ] = clipPlane.x; + projectionMatrix.elements[ 6 ] = clipPlane.y; + projectionMatrix.elements[ 10 ] = clipPlane.z + 1.0 - clipBias; + projectionMatrix.elements[ 14 ] = clipPlane.w; + + // Render + + scope.visible = false; + + var currentRenderTarget = renderer.getRenderTarget(); + + var currentVrEnabled = renderer.vr.enabled; + var currentShadowAutoUpdate = renderer.shadowMap.autoUpdate; + + renderer.vr.enabled = false; // Avoid camera modification and recursion + renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows + + renderer.render( scene, virtualCamera, renderTarget, true ); + + renderer.vr.enabled = currentVrEnabled; + renderer.shadowMap.autoUpdate = currentShadowAutoUpdate; + + renderer.setRenderTarget( currentRenderTarget ); + + // Restore viewport + + var bounds = camera.bounds; + + if ( bounds !== undefined ) { + + var size = renderer.getSize(); + var pixelRatio = renderer.getPixelRatio(); + + viewport.x = bounds.x * size.width * pixelRatio; + viewport.y = bounds.y * size.height * pixelRatio; + viewport.z = bounds.z * size.width * pixelRatio; + viewport.w = bounds.w * size.height * pixelRatio; + + renderer.state.viewport( viewport ); + + } + + scope.visible = true; + + }; + + this.getRenderTarget = function () { + + return renderTarget; + + }; + +}; + +THREE.Reflector.prototype = Object.create( THREE.Mesh.prototype ); +THREE.Reflector.prototype.constructor = THREE.Reflector; + +THREE.Reflector.ReflectorShader = { + + uniforms: { + + 'color': { + type: 'c', + value: null + }, + + 'addColor': { + type: 'c', + value: null + }, + + 'tDiffuse': { + type: 't', + value: null + }, + + 'textureMatrix': { + type: 'm4', + value: null + } + + }, + + vertexShader: [ + 'uniform mat4 textureMatrix;', + 'varying vec4 vUv;', + + 'void main() {', + + ' vUv = textureMatrix * vec4( position, 1.0 );', + + ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', + + '}' + ].join( '\n' ), + + fragmentShader: [ + 'uniform vec3 color;', + 'uniform vec3 addColor;', + 'uniform sampler2D tDiffuse;', + 'varying vec4 vUv;', + + 'float blendOverlay( float base, float blend ) {', + + ' return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );', + + '}', + + 'vec3 blendOverlay( vec3 base, vec3 blend ) {', + + ' return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );', + + '}', + + 'void main() {', + + ' vec4 base = texture2DProj( tDiffuse, vUv );', + ' vec3 addColorC;', + ' if (base.r > 0.01 || base.g > 0.01 || base.b > 0.01) {addColorC = addColor;} else {addColorC = vec3(0.0);}', + ' gl_FragColor = vec4( blendOverlay( base.rgb, color ) + addColorC, 1.0 );', + + '}' + ].join( '\n' ) +}; From c189f3d5bf9959ca4c23bea45e072dd4b08285ed Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 18 Oct 2019 23:06:50 -0400 Subject: [PATCH 140/562] Add initial mirror mesh --- app.html | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/app.html b/app.html index 3eb303c..0ba7ecf 100644 --- a/app.html +++ b/app.html @@ -9,6 +9,7 @@ + @@ -6958,6 +6959,28 @@ }; _loadDefaultGltf(); +const mirrorMesh = (() => { + const geometry = new THREE.PlaneBufferGeometry(1, 1); + const mesh = new THREE.Reflector(geometry, { + clipBias: 0.003, + textureWidth: 1024 * window.devicePixelRatio, + textureHeight: 1024 * window.devicePixelRatio, + color: 0x889999, + addColor: 0x300000, + recursion: 1 + }); + // mesh.position.set(-1, 1.5, -2.1); + mesh.position.set(0, 1, 1); + /* mesh.rotation.order = 'YXZ'; + mesh.rotation.y = Math.PI; */ + /* const material = new THREE.MeshBasicMaterial({ + color: 0xFF0000, + }); + const mesh = new THREE.Mesh(geometry, material); */ + return mesh; +})(); +scene.add(mirrorMesh); + function _updateCoord() { const {c} = parseQuery(window.location.search); let match; From 430c054e09e56a17f22e6d712cf28b1fef7f06b3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 18 Oct 2019 23:24:55 -0400 Subject: [PATCH 141/562] Update Reflector.js --- Reflector.js | 46 +++++++++++++--------------------------------- 1 file changed, 13 insertions(+), 33 deletions(-) diff --git a/Reflector.js b/Reflector.js index 3f9be10..47fdc2b 100644 --- a/Reflector.js +++ b/Reflector.js @@ -13,7 +13,6 @@ THREE.Reflector = function ( geometry, options ) { options = options || {}; var color = ( options.color !== undefined ) ? new THREE.Color( options.color ) : new THREE.Color( 0x7F7F7F ); - var addColor = ( options.addColor !== undefined ) ? new THREE.Color( options.addColor ) : new THREE.Color( 0x000000 ); var textureWidth = options.textureWidth || 512; var textureHeight = options.textureHeight || 512; var clipBias = options.clipBias || 0; @@ -29,7 +28,6 @@ THREE.Reflector = function ( geometry, options ) { var rotationMatrix = new THREE.Matrix4(); var lookAtPosition = new THREE.Vector3( 0, 0, - 1 ); var clipPlane = new THREE.Vector4(); - var viewport = new THREE.Vector4(); var view = new THREE.Vector3(); var target = new THREE.Vector3(); @@ -59,13 +57,11 @@ THREE.Reflector = function ( geometry, options ) { vertexShader: shader.vertexShader } ); - material.uniforms.tDiffuse.value = renderTarget.texture; - material.uniforms.color.value = color; - material.uniforms.addColor.value = addColor; - material.uniforms.textureMatrix.value = textureMatrix; + material.uniforms[ "tDiffuse" ].value = renderTarget.texture; + material.uniforms[ "color" ].value = color; + material.uniforms[ "textureMatrix" ].value = textureMatrix; this.material = material; - this.renderOrder = - Infinity; // render first this.onBeforeRender = function ( renderer, scene, camera ) { @@ -82,16 +78,17 @@ THREE.Reflector = function ( geometry, options ) { rotationMatrix.extractRotation( scope.matrixWorld ); - normal.set( 0, 0, -1 ); + normal.set( 0, 0, 1 ); normal.applyMatrix4( rotationMatrix ); view.subVectors( reflectorWorldPosition, cameraWorldPosition ); // Avoid rendering when reflector is facing away - if ( view.dot( normal ) < 0 ) return; + if ( view.dot( normal ) > 0 ) return; - view.copy(cameraWorldPosition); + view.reflect( normal ).negate(); + view.add( reflectorWorldPosition ); rotationMatrix.extractRotation( camera.matrixWorld ); @@ -162,7 +159,9 @@ THREE.Reflector = function ( geometry, options ) { renderer.vr.enabled = false; // Avoid camera modification and recursion renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows - renderer.render( scene, virtualCamera, renderTarget, true ); + renderer.setRenderTarget( renderTarget ); + renderer.clear(); + renderer.render( scene, virtualCamera ); renderer.vr.enabled = currentVrEnabled; renderer.shadowMap.autoUpdate = currentShadowAutoUpdate; @@ -171,17 +170,9 @@ THREE.Reflector = function ( geometry, options ) { // Restore viewport - var bounds = camera.bounds; + var viewport = camera.viewport; - if ( bounds !== undefined ) { - - var size = renderer.getSize(); - var pixelRatio = renderer.getPixelRatio(); - - viewport.x = bounds.x * size.width * pixelRatio; - viewport.y = bounds.y * size.height * pixelRatio; - viewport.z = bounds.z * size.width * pixelRatio; - viewport.w = bounds.w * size.height * pixelRatio; + if ( viewport !== undefined ) { renderer.state.viewport( viewport ); @@ -207,22 +198,14 @@ THREE.Reflector.ReflectorShader = { uniforms: { 'color': { - type: 'c', - value: null - }, - - 'addColor': { - type: 'c', value: null }, 'tDiffuse': { - type: 't', value: null }, 'textureMatrix': { - type: 'm4', value: null } @@ -243,7 +226,6 @@ THREE.Reflector.ReflectorShader = { fragmentShader: [ 'uniform vec3 color;', - 'uniform vec3 addColor;', 'uniform sampler2D tDiffuse;', 'varying vec4 vUv;', @@ -262,9 +244,7 @@ THREE.Reflector.ReflectorShader = { 'void main() {', ' vec4 base = texture2DProj( tDiffuse, vUv );', - ' vec3 addColorC;', - ' if (base.r > 0.01 || base.g > 0.01 || base.b > 0.01) {addColorC = addColor;} else {addColorC = vec3(0.0);}', - ' gl_FragColor = vec4( blendOverlay( base.rgb, color ) + addColorC, 1.0 );', + ' gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );', '}' ].join( '\n' ) From 6b359fb0c8373faa736f9bc2c8762256a48ba096 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 18 Oct 2019 23:27:45 -0400 Subject: [PATCH 142/562] Updte reflector size --- app.html | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app.html b/app.html index 0ba7ecf..6d7cd88 100644 --- a/app.html +++ b/app.html @@ -6960,11 +6960,11 @@ _loadDefaultGltf(); const mirrorMesh = (() => { - const geometry = new THREE.PlaneBufferGeometry(1, 1); + const geometry = new THREE.PlaneBufferGeometry(1, 2); const mesh = new THREE.Reflector(geometry, { clipBias: 0.003, textureWidth: 1024 * window.devicePixelRatio, - textureHeight: 1024 * window.devicePixelRatio, + textureHeight: 2048 * window.devicePixelRatio, color: 0x889999, addColor: 0x300000, recursion: 1 From baf5ad92e99ad7d372b16f1a606c8137eabfb043 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Fri, 18 Oct 2019 23:31:24 -0400 Subject: [PATCH 143/562] Dead code cleanup --- vrarmik.html | 25 +------------------------ 1 file changed, 1 insertion(+), 24 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 44f39d8..33de864 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -160,26 +160,14 @@ window.bones = bones; o.bind(window.skeleton); - // window.bindMatrix = bindMatrix.clone(); } }); - fixSkeletonZForward(window.bones[0], { - /* preRotations: { - 'Left_arm': new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI*0.25).inverse(), - 'Right_arm': new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI*0.25).inverse(), - }, */ - }); + fixSkeletonZForward(window.bones[0]); model.traverse(o => { if (o.isSkinnedMesh) { o.bind(window.skeleton); } }); - /* ['Left_arm', 'Right_arm'].forEach((name, i) => { - const bone = bones.find(bone => bone.name === name); - if (bone) { - bone.quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (i === 0 ? 1 : -1) * Math.PI*0.25)); - } - }); */ model.updateMatrixWorld(true); model.traverse(o => { @@ -189,15 +177,9 @@ if (o.isSkinnedMesh) { const {skeleton, bindMatrix} = o; const {bones} = skeleton; - /* fixSkeletonZForward(bones[0], { - exclude: ['Hips', 'Head'], - }); - o.bind(skeleton, bindMatrix); */ - // o.updateMatrixWorld(true); for (const k in modelBones) { if (!modelBones[k]) { modelBones[k] = bones.find(bone => bone.name === k); - // modelBones[k].initialDirectionQuaternion = _getChildDirectionQuaternion(modelBones[k]); modelBones[k].initialPosition = modelBones[k].position.clone(); modelBones[k].initialQuaternion = modelBones[k].quaternion.clone(); console.log('found bone', k, modelBones[k], modelBones[k].children, new THREE.Euler().setFromQuaternion(modelBones[k].initialQuaternion, 'YXZ'), 'YXZ'); @@ -205,11 +187,6 @@ modelBones[k].initialMatrixWorld = modelBones[k].matrixWorld.clone(); } } - /* for (const k in modelBones) { - if (modelBones[k] && modelBones[k].parent) { - modelBones[k].parent.remove(modelBones[k]); - } - } */ } }); From c60a7a86134cac8acfbdd1ec5bf9444dcb93b426 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 19 Oct 2019 00:21:17 -0400 Subject: [PATCH 144/562] Add missing neck bone binding --- vrarmik/Rig.js | 1 + 1 file changed, 1 insertion(+) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 9509451..b278bbc 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -49,6 +49,7 @@ class Rig { hips: this.legsManager.hips, spine: this.shoulderTransforms.spine, chest: this.shoulderTransforms.transform, + neck: this.shoulderTransforms.neck, leftShoulder: this.shoulderTransforms.leftShoulderAnchor, leftUpperArm: this.shoulderTransforms.leftArm.upperArm, leftLowerArm: this.shoulderTransforms.leftArm.lowerArm, From 274d9dab1274a5dd330334977c2b7d3ab474af95 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 19 Oct 2019 00:24:06 -0400 Subject: [PATCH 145/562] Major API cleanup --- vrarmik.html | 247 ++++++------------------------------------------- vrarmik/Rig.js | 214 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 235 insertions(+), 226 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 33de864..2bb67bd 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -96,7 +96,7 @@ scene.remove(meshes.lowerLegRight); scene.remove(meshes.footRight); */ -let rig, model, modelBones, modelBonesMappings; +let rig, model; const _getChildDirectionQuaternion = o => { // const worldPosition = o.getWorldPosition(new Vector3()); const vector = new Vector3(0, 0, 0); @@ -125,124 +125,37 @@ } }; new THREE.GLTFLoader().load('model4.glb', object => { - modelBones = { - Hips: null, - Spine: null, - Chest: null, - Neck: null, - Head: null, - - Left_shoulder: null, - Left_arm: null, - Left_elbow: null, - Left_wrist: null, - Left_leg: null, - Left_knee: null, - Left_ankle: null, - - Right_shoulder: null, - Right_arm: null, - Right_elbow: null, - Right_wrist: null, - Right_leg: null, - Right_knee: null, - Right_ankle: null, - }; - model = object.scene; - model.updateMatrixWorld(true); - model.traverse(o => { - if (o.isSkinnedMesh) { - const {skeleton, bindMatrix} = o; - const {bones} = skeleton; - window.skeleton = skeleton; - window.bones = bones; - - o.bind(window.skeleton); - } - }); - fixSkeletonZForward(window.bones[0]); - model.traverse(o => { - if (o.isSkinnedMesh) { - o.bind(window.skeleton); - } - }); - model.updateMatrixWorld(true); - - model.traverse(o => { - if (o.isMesh) { - o.frustumCulled = false; - } - if (o.isSkinnedMesh) { - const {skeleton, bindMatrix} = o; - const {bones} = skeleton; - for (const k in modelBones) { - if (!modelBones[k]) { - modelBones[k] = bones.find(bone => bone.name === k); - modelBones[k].initialPosition = modelBones[k].position.clone(); - modelBones[k].initialQuaternion = modelBones[k].quaternion.clone(); - console.log('found bone', k, modelBones[k], modelBones[k].children, new THREE.Euler().setFromQuaternion(modelBones[k].initialQuaternion, 'YXZ'), 'YXZ'); - modelBones[k].initialScale = modelBones[k].scale.clone(); - modelBones[k].initialMatrixWorld = modelBones[k].matrixWorld.clone(); - } - } - } + rig = new Rig(model, { + boneMappings: { + Hips: 'Hips', + Spine: 'Spine', + Chest: 'Chest', + Neck: 'Neck', + Head: 'Head', + + Left_shoulder: 'Left_shoulder', + Left_arm: 'Left_arm', + Left_elbow: 'Left_elbow', + Left_wrist: 'Left_wrist', + Left_leg: 'Left_leg', + Left_knee: 'Left_knee', + Left_ankle: 'Left_ankle', + + Right_shoulder: 'Right_shoulder', + Right_arm: 'Right_arm', + Right_elbow: 'Right_elbow', + Right_wrist: 'Right_wrist', + Right_leg: 'Right_leg', + Right_knee: 'Right_knee', + Right_ankle: 'Right_ankle', + }, }); - - const _getOffset = (bone, parent = bone.parent) => bone.getWorldPosition(new Vector3()).sub(parent.getWorldPosition(new Vector3())); - const setups = { - spine: _getOffset(modelBones.Spine), - hips: _getOffset(modelBones.Spine, modelBones.Head), - neck: _getOffset(modelBones.Neck), - head: _getOffset(modelBones.Head), - - leftShoulder: _getOffset(modelBones.Right_shoulder), - leftUpperArm: _getOffset(modelBones.Right_arm), - leftLowerArm: _getOffset(modelBones.Right_elbow), - leftHand: _getOffset(modelBones.Right_wrist), - - rightShoulder: _getOffset(modelBones.Left_shoulder), - rightUpperArm: _getOffset(modelBones.Left_arm), - rightLowerArm: _getOffset(modelBones.Left_elbow), - rightHand: _getOffset(modelBones.Left_wrist), - - leftUpperLeg: _getOffset(modelBones.Right_leg), - leftLowerLeg: _getOffset(modelBones.Right_knee), - leftFoot: _getOffset(modelBones.Right_ankle), - - rightUpperLeg: _getOffset(modelBones.Left_leg), - rightLowerLeg: _getOffset(modelBones.Left_knee), - rightFoot: _getOffset(modelBones.Left_ankle), - }; - rig = new Rig(setups); /* for (const k in setups) { setups[k] = setups[k].toArray(); } console.log(JSON.stringify(setups, null, 2)); */ - modelBonesMappings = { - Hips: rig.outputs.hips, - Spine: rig.outputs.spine, - Chest: rig.outputs.chest, - Neck: rig.outputs.neck, - Head: rig.outputs.hmd, - - Left_shoulder: rig.outputs.rightShoulder, - Left_arm: rig.outputs.rightUpperArm, - Left_elbow: rig.outputs.rightLowerArm, - Left_wrist: rig.outputs.rightHand, - Left_leg: rig.outputs.rightUpperLeg, - Left_knee: rig.outputs.rightLowerLeg, - Left_ankle: rig.outputs.rightFoot, - - Right_shoulder: rig.outputs.leftShoulder, - Right_arm: rig.outputs.leftUpperArm, - Right_elbow: rig.outputs.leftLowerArm, - Right_wrist: rig.outputs.leftHand, - Right_leg: rig.outputs.leftUpperLeg, - Right_knee: rig.outputs.leftLowerLeg, - Right_ankle: rig.outputs.leftFoot, - }; // debugger; scene.add(model); @@ -338,115 +251,7 @@ meshes.lowerLegRight.quaternion.copy(rig.outputs.rightLowerLeg.rotation); meshes.footRight.position.copy(rig.outputs.rightFoot.position); meshes.footRight.quaternion.copy(rig.outputs.rightFoot.rotation); - - for (const k in modelBones) { - const modelBone = modelBones[k]; - const modelBoneMapping = modelBonesMappings[k]; - /* if (modelBone) { - if (['Chest', 'Left_arm', 'Left_elbow', 'Left_wrist'].includes(k)) { - if (!modelBone.axesHelper) { - modelBone.axesHelper = new THREE.AxesHelper(); - scene.add(modelBone.axesHelper); - } - modelBone.getWorldPosition(modelBone.axesHelper.position); - modelBone.getWorldQuaternion(modelBone.axesHelper.quaternion); - modelBone.getWorldScale(modelBone.axesHelper.scale); - } - } */ - if (modelBone && modelBoneMapping) { - if (k === 'Hips') { - modelBone.position.copy(modelBoneMapping.position); - } - modelBone.quaternion - .copy(modelBone.initialQuaternion) - - if (['Hips', 'Spine', 'Chest', 'Neck', 'Head'].includes(k)) { - modelBone.quaternion - .multiply(modelBoneMapping.localRotation) - } - - if (['Left_leg'].includes(k)) { - modelBone.quaternion - .multiply(modelBoneMapping.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) - } - if (['Left_knee'].includes(k)) { - modelBone.quaternion - .multiply(modelBoneMapping.localRotation) - // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) - } - if (['Left_ankle'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)) - } - - if (['Right_leg'].includes(k)) { - modelBone.quaternion - .multiply(modelBoneMapping.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) - } - if (['Right_knee'].includes(k)) { - modelBone.quaternion - .multiply(modelBoneMapping.localRotation) - // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) - } - if (['Right_ankle'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)) - } - - if (['Left_shoulder'].includes(k)) { - modelBone.quaternion - .multiply(modelBoneMapping.localRotation) - } - if (['Left_arm'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // forward - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI*0.6)) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // down - } - if (['Left_elbow'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - } - if (['Left_wrist'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // center - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // ip - } - - if (['Right_shoulder'].includes(k)) { - modelBone.quaternion - .multiply(modelBoneMapping.localRotation) - } - if (['Right_arm'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // forward - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI*0.6)) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // down - } - if (['Right_elbow'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - } - if (['Right_wrist'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneMapping.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2)) // center - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI/8)) // up - } - - modelBone.updateMatrixWorld(); - } - } -} + } renderer.render(scene, camera); } diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index b278bbc..e7393ad 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -10,11 +10,97 @@ const poses = { }; class Rig { - constructor(setups) { - const rig = new GameObject('rig'); - this.poseManager = rig.AddComponent(PoseManager); - this.shoulderTransforms = rig.AddComponent(ShoulderTransforms); - this.legsManager = rig.AddComponent(LegsManager); + constructor(model, {boneMappings}) { + const modelBones = { + Hips: null, + Spine: null, + Chest: null, + Neck: null, + Head: null, + + Left_shoulder: null, + Left_arm: null, + Left_elbow: null, + Left_wrist: null, + Left_leg: null, + Left_knee: null, + Left_ankle: null, + + Right_shoulder: null, + Right_arm: null, + Right_elbow: null, + Right_wrist: null, + Right_leg: null, + Right_knee: null, + Right_ankle: null, + }; + this.modelBones = modelBones; + + model.updateMatrixWorld(true); + let skeleton; + model.traverse(o => { + if (o.isSkinnedMesh) { + if (!skeleton) { + skeleton = o.skeleton; + } + + o.bind(skeleton); + } + }); + fixSkeletonZForward(skeleton.bones[0]); + model.traverse(o => { + if (o.isSkinnedMesh) { + o.bind(skeleton); + } + }); + model.updateMatrixWorld(true); + + model.traverse(o => { + if (o.isMesh) { + o.frustumCulled = false; + } + if (o.isSkinnedMesh) { + for (const k in modelBones) { + if (!modelBones[k]) { + const userlandBoneName = boneMappings[k]; + modelBones[k] = skeleton.bones.find(bone => bone.name === userlandBoneName); + modelBones[k].initialQuaternion = modelBones[k].quaternion.clone(); + console.log('found bone', k, userlandBoneName, modelBones[k], modelBones[k].children); + } + } + } + }); + + const _getOffset = (bone, parent = bone.parent) => bone.getWorldPosition(new Vector3()).sub(parent.getWorldPosition(new Vector3())); + const setups = { + spine: _getOffset(modelBones.Spine), + hips: _getOffset(modelBones.Spine, modelBones.Head), + neck: _getOffset(modelBones.Neck), + head: _getOffset(modelBones.Head), + + leftShoulder: _getOffset(modelBones.Right_shoulder), + leftUpperArm: _getOffset(modelBones.Right_arm), + leftLowerArm: _getOffset(modelBones.Right_elbow), + leftHand: _getOffset(modelBones.Right_wrist), + + rightShoulder: _getOffset(modelBones.Left_shoulder), + rightUpperArm: _getOffset(modelBones.Left_arm), + rightLowerArm: _getOffset(modelBones.Left_elbow), + rightHand: _getOffset(modelBones.Left_wrist), + + leftUpperLeg: _getOffset(modelBones.Right_leg), + leftLowerLeg: _getOffset(modelBones.Right_knee), + leftFoot: _getOffset(modelBones.Right_ankle), + + rightUpperLeg: _getOffset(modelBones.Left_leg), + rightLowerLeg: _getOffset(modelBones.Left_knee), + rightFoot: _getOffset(modelBones.Left_ankle), + }; + + const rigObject = new GameObject('rig'); + this.poseManager = rigObject.AddComponent(PoseManager); + this.shoulderTransforms = rigObject.AddComponent(ShoulderTransforms); + this.legsManager = rigObject.AddComponent(LegsManager); this.shoulderTransforms.spine.localPosition = setups.spine; this.shoulderTransforms.localPosition = setups.hips; @@ -65,11 +151,129 @@ class Rig { rightLowerLeg: this.legsManager.rightLeg.lowerLeg, rightFoot: this.legsManager.rightLeg.foot, }; + this.modelBoneOutputs = { + Hips: this.outputs.hips, + Spine: this.outputs.spine, + Chest: this.outputs.chest, + Neck: this.outputs.neck, + Head: this.outputs.hmd, + + Left_shoulder: this.outputs.rightShoulder, + Left_arm: this.outputs.rightUpperArm, + Left_elbow: this.outputs.rightLowerArm, + Left_wrist: this.outputs.rightHand, + Left_leg: this.outputs.rightUpperLeg, + Left_knee: this.outputs.rightLowerLeg, + Left_ankle: this.outputs.rightFoot, + + Right_shoulder: this.outputs.leftShoulder, + Right_arm: this.outputs.leftUpperArm, + Right_elbow: this.outputs.leftLowerArm, + Right_wrist: this.outputs.leftHand, + Right_leg: this.outputs.leftUpperLeg, + Right_knee: this.outputs.leftLowerLeg, + Right_ankle: this.outputs.leftFoot, + }; GameObject.startAll(); } update() { GameObject.updateAll(); + + for (const k in this.modelBones) { + const modelBone = this.modelBones[k]; + const modelBoneOutput = this.modelBoneOutputs[k]; + + if (k === 'Hips') { + modelBone.position.copy(modelBoneOutput.position); + } + modelBone.quaternion + .copy(modelBone.initialQuaternion) + + if (['Hips', 'Spine', 'Chest', 'Neck', 'Head'].includes(k)) { + modelBone.quaternion + .multiply(modelBoneOutput.localRotation) + } + + if (['Left_leg'].includes(k)) { + modelBone.quaternion + .multiply(modelBoneOutput.localRotation) + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) + } + if (['Left_knee'].includes(k)) { + modelBone.quaternion + .multiply(modelBoneOutput.localRotation) + // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) + } + if (['Left_ankle'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)) + } + + if (['Right_leg'].includes(k)) { + modelBone.quaternion + .multiply(modelBoneOutput.localRotation) + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) + } + if (['Right_knee'].includes(k)) { + modelBone.quaternion + .multiply(modelBoneOutput.localRotation) + // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) + } + if (['Right_ankle'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)) + } + + if (['Left_shoulder'].includes(k)) { + modelBone.quaternion + .multiply(modelBoneOutput.localRotation) + } + if (['Left_arm'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // forward + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI*0.6)) + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // down + } + if (['Left_elbow'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + } + if (['Left_wrist'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // center + .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // ip + } + + if (['Right_shoulder'].includes(k)) { + modelBone.quaternion + .multiply(modelBoneOutput.localRotation) + } + if (['Right_arm'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // forward + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI*0.6)) + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // down + } + if (['Right_elbow'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + } + if (['Right_wrist'].includes(k)) { + modelBone.quaternion + .premultiply(modelBoneOutput.localRotation) + .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2)) // center + .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI/8)) // up + } + modelBone.updateMatrixWorld(); + } } } export default Rig; \ No newline at end of file From 2c88d2caa1def584c1c68c97585f3d66bebd5b32 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 19 Oct 2019 00:47:52 -0400 Subject: [PATCH 146/562] Bugfix missing avatar rig file import --- app.html | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/app.html b/app.html index 6d7cd88..6a1c256 100644 --- a/app.html +++ b/app.html @@ -26,9 +26,8 @@ - - + + + + + + @@ -14,6 +204,31 @@ + + +
+
+ + + + + +
+ +
+

Examples

+

+ model.glb
+ model2.vrm
+ model3.unitypackage
+

+
+ +
+
From 2da45358797149ff1cd289b9b95d79be48bec70b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 22 Oct 2019 20:45:46 -0400 Subject: [PATCH 209/562] Lower height in avatar demo page --- vrarmik.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index 09f1498..e8389fa 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -460,7 +460,7 @@

Examples

function animate() { if (rig) { const positionOffset = Math.sin((realDateNow()%10000)/10000*Math.PI*2)*2; - const standFactor = 1.3412381613714757 - 0.3 + Math.sin((realDateNow()%2000)/2000*Math.PI*2)*0.3; + const standFactor = 1.3412381613714757 - 0.4 + Math.sin((realDateNow()%2000)/2000*Math.PI*2)*0.3; const rotationAngle = (realDateNow()%10000)/10000*Math.PI*2; // rig.inputs.hmd.position = new Vector3(positionOffset, 0.6 + standFactor, 0); From 1f5a62895f98cf405e27b9bf713b7b6ec80a9e11 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 22 Oct 2019 20:51:45 -0400 Subject: [PATCH 210/562] Add Reflector.js include --- vrarmik.html | 1 + 1 file changed, 1 insertion(+) diff --git a/vrarmik.html b/vrarmik.html index e8389fa..726db08 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -201,6 +201,7 @@ + From e547d062c125c22c1c53609a4e55a214827ae485 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 22 Oct 2019 20:51:57 -0400 Subject: [PATCH 211/562] Add initial mirror mesh --- vrarmik.html | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/vrarmik.html b/vrarmik.html index 726db08..aa07304 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -322,6 +322,31 @@

Examples

scene.remove(meshes.lowerLegRight); scene.remove(meshes.footRight); */ +const mirrorMesh = (() => { + const geometry = new THREE.PlaneBufferGeometry(1, 2); + const mesh = new THREE.Reflector(geometry, { + clipBias: 0.003, + textureWidth: 1024 * window.devicePixelRatio, + textureHeight: 2048 * window.devicePixelRatio, + color: 0x889999, + addColor: 0x300000, + recursion: 1 + }); + mesh.position.set(0, 1, -1); + /* mesh.onBeforeRender2 = () => { + if (model) { + model.visible = true; + } + }; + mesh.onAfterRender2 = () => { + if (model) { + model.visible = false; + } + }; */ + return mesh; +})(); +scene.add(mirrorMesh); + const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); let rig = null; From b4d3a858b99ac3a9b48cea85baa08f084acad8b6 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 22 Oct 2019 21:00:59 -0400 Subject: [PATCH 212/562] Clean up header --- vrarmik.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index aa07304..78c3e10 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -210,13 +210,13 @@
- - + +
From 27e4efbc0baa11cfeb17e6159181ce2f021e3f6d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 22 Oct 2019 21:21:50 -0400 Subject: [PATCH 213/562] Add initial file upload button --- vrarmik.html | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index 78c3e10..6b07d7c 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -126,10 +126,12 @@ a:active { color: #1976d2; } -.buttons { +.body > .buttons { position: absolute; right: 30px; bottom: 30px; +} +.buttons { display: flex; margin: 5px 20px; } @@ -226,6 +228,12 @@

Examples

model2.vrm
model3.unitypackage

+
+ +
From bf57212b1f30a1b76b8dad6a7c36212489616134 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 22 Oct 2019 21:22:00 -0400 Subject: [PATCH 214/562] Hook in initial file upload button --- vrarmik.html | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/vrarmik.html b/vrarmik.html index 6b07d7c..1ee05d8 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -442,6 +442,26 @@

Examples

} }; +const _bindUploadFileButton = inputFileEl => { + inputFileEl.addEventListener('change', e => { + const {files} = e.target; + if (files.length === 1) { + const [file] = files; + const dataUrl = URL.createObjectURL(file); + _loadModel(dataUrl, file.name); + } + + const {parentNode} = inputFileEl; + parentNode.removeChild(inputFileEl); + const newInputFileEl = document.createElement('input'); + newInputFileEl.type = 'file'; + newInputFileEl.id = 'upload-file-button'; + newInputFileEl.style.display = 'none'; + parentNode.appendChild(newInputFileEl); + _bindUploadFileButton(newInputFileEl); + }); +}; +_bindUploadFileButton(document.getElementById('upload-file-button')); window.document.addEventListener('dragover', e => { e.preventDefault(); }); From af6baf102cd52581b6a8c87bbab2b4f78a2b2f48 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 22 Oct 2019 21:41:36 -0400 Subject: [PATCH 215/562] Auto-detect FBX file in .unitypackage --- vrarmik.html | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 1ee05d8..af70830 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -426,17 +426,30 @@

Examples

return url; }); - const modelFileUrl = filesystem.find(file => file.pathname === 'Assets/1Avatars/rachel gardner 1/rachel gardner NEW.fbx').url; - const loader = new THREE.FBXLoader(manager); - loader.load(modelFileUrl, object => { - _rigModel(object); - }, function onprogress() { - - }, function onerror(err) { - console.warn(err); - }); - // window.loader = loader; - console.log('got filesystem', modelFileUrl, loader); + const modelFiles = filesystem.filter(file => /\.fbx/.test(file.pathname)).map(file => { + const pathnamePrefix = file.pathname.replace(/[^\/]+$/, ''); + const numSiblingFiles = filesystem.filter(file => file.pathname.startsWith(pathnamePrefix)).length; + return { + file, + numSiblingFiles, + }; + }).sort((a, b) => b.numSiblingFiles - a.numSiblingFiles).map(({file}) => file); + if (modelFiles.length > 0) { + const modelFile = modelFiles[0]; + const modelFileUrl = modelFile.url; + const loader = new THREE.FBXLoader(manager); + loader.load(modelFileUrl, object => { + _rigModel(object); + }, function onprogress() { + + }, function onerror(err) { + console.warn(err); + }); + // window.loader = loader; + // console.log('got filesystem', modelFileUrl, loader); + } else { + throw new Error('no model file in package'); + } } else { throw new Error('unknown file type'); } From e6c5caa36da9a91ac6c5f7b36417945afbe405ae Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 23 Oct 2019 01:30:48 -0400 Subject: [PATCH 216/562] Small dead code cleanup --- vrarmik.html | 1 - 1 file changed, 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index af70830..cd82114 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -401,7 +401,6 @@

Examples

const filename = match[1]; const url = assetFile.getBlobUrl(); filesystem.push({ - id, pathname, filename, url, From ddf0ff4aa83c3dc68085d813ad68343107c40fb8 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 23 Oct 2019 01:33:04 -0400 Subject: [PATCH 217/562] Major eyes detection debugging --- vrarmik.html | 167 ++++++++++++++++++++++++++++++++++--------------- vrarmik/Rig.js | 70 +++++++++++++++++---- 2 files changed, 174 insertions(+), 63 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index cd82114..c873bc1 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -207,6 +207,7 @@ +
@@ -371,14 +372,119 @@

Examples

scene.add(model); window.model = model; }; -const _loadModel = async (href, filename = href) => { - if (/\.(?:glb|vrm)$/.test(filename)) { +const _getFileType = filename => { + if (/\.(?:gltf|glb|vrm)$/.test(filename)) { + return 'gltf'; + } else if (/\.fbx$/.test(filename)) { + return 'fbx'; + } else if (/\.(?:tar\.gz|tgz|unitypackage)$/.test(filename)) { + return 'tgz'; + } else if (/\.(?:zip)$/.test(filename)) { + return 'zip'; + } else { + return null; + } +}; +const _pathname2Filename = pathname => { + const match = pathname.match(/([^\/]+)$/); + return match && match[1]; +}; +const _loadModelFilesystem = filesystem => { + const manager = new THREE.LoadingManager(); + manager.setURLModifier(url => { + // console.log('load url', url); + const match = url.match(/([^\/]+)$/); + if (match) { + const filename = match[1]; + const file = filesystem.find(file => file.filename === filename); + if (file) { + // console.log('replace url', url, file.url); + url = file.url; + } + } + return url; + }); + + const modelFiles = filesystem.filter(file => /\.(?:fbx|gltf|glb)/.test(file.pathname)).map(file => { + const pathnamePrefix = file.pathname.replace(/[^\/]+$/, ''); + const numSiblingFiles = filesystem.filter(file => file.pathname.startsWith(pathnamePrefix)).length; + return { + file, + numSiblingFiles, + }; + }).sort((a, b) => b.numSiblingFiles - a.numSiblingFiles).map(({file}) => file); + if (modelFiles.length > 0) { + const modelFile = modelFiles[0]; + console.log('got model file', modelFile); + const modelFileUrl = modelFile.url; + if (/\.fbx$/.test(modelFile.pathname)) { + new THREE.FBXLoader(manager).load(modelFileUrl, object => { + _rigModel(object); + }, function onprogress() {}, function onerror(err) { + console.warn(err); + }); + } else { + new THREE.GLTFLoader(manager).load(modelFileUrl, object => { + _rigModel(object.scene); + }, xhr => {}, err => { + console.warn(err); + }); + } + } else { + throw new Error('no model file in package'); + } +}; +const _loadModelUrl = async (href, filename = href) => { + const fileType = _getFileType(filename); + if (fileType === 'gltf') { new THREE.GLTFLoader().load(href, object => { _rigModel(object.scene); }, xhr => {}, err => { console.warn(err); }); - } else if (/\.unitypackage$/.test(filename)) { + } else if (fileType === 'fbx') { + new THREE.FBXLoader().load(href, object => { + _rigModel(object); + }, xhr => {}, err => { + console.warn(err); + }); + } else if (fileType === 'zip') { + const unitypackageRes = await fetch(href); + const blob = await unitypackageRes.blob(); + zip.createReader(new zip.BlobReader(blob), function(reader) { + reader.getEntries(async function(entries) { + const filesystem = []; + for (let i = 0; i < entries.length; i++) { + const entry = entries[i]; + const pathname = entry.filename; + const filename = _pathname2Filename(pathname); + const blob = await new Promise((accept, reject) => { + entry.getData(new zip.BlobWriter('application/octet-stream'), function(blob) { + accept(blob); + }, function(current, total) { + // onprogress callback + }); + }); + const url = URL.createObjectURL(blob); + filesystem.push({ + pathname, + filename, + url, + }); + // console.log('got blob', entry, blob, pathname, filename, url); + } + // console.log('got filesystem', filesystem); + _loadModelFilesystem(filesystem); + + /* // close the zip reader + reader.close(function() { + // onclose callback + }); */ + }); + }, function(err) { + console.warn(err); + }); + } else if (fileType === 'tgz') { const unitypackageRes = await fetch(href); const arraybuffer = await unitypackageRes.arrayBuffer(); const inflatedArrayBuffer = new Zlib.Gunzip(new Uint8Array(arraybuffer)).decompress().buffer; @@ -397,8 +503,7 @@

Examples

const assetFileName = `${id}/asset`; const assetFile = files.find(file => file.name === assetFileName); if (assetFile) { - const match = pathname.match(/([^\/]+)$/); - const filename = match[1]; + const filename = _pathname2Filename(pathname); const url = assetFile.getBlobUrl(); filesystem.push({ pathname, @@ -408,49 +513,9 @@

Examples

} } } - // window.filesystem = filesystem; - - const manager = new THREE.LoadingManager(); - manager.setURLModifier(url => { - // console.log('load url', url); - const match = url.match(/([^\/]+)$/); - if (match) { - const filename = match[1]; - const file = filesystem.find(file => file.filename === filename); - if (file) { - // console.log('replace url', url, file.url); - url = file.url; - } - } - return url; - }); - - const modelFiles = filesystem.filter(file => /\.fbx/.test(file.pathname)).map(file => { - const pathnamePrefix = file.pathname.replace(/[^\/]+$/, ''); - const numSiblingFiles = filesystem.filter(file => file.pathname.startsWith(pathnamePrefix)).length; - return { - file, - numSiblingFiles, - }; - }).sort((a, b) => b.numSiblingFiles - a.numSiblingFiles).map(({file}) => file); - if (modelFiles.length > 0) { - const modelFile = modelFiles[0]; - const modelFileUrl = modelFile.url; - const loader = new THREE.FBXLoader(manager); - loader.load(modelFileUrl, object => { - _rigModel(object); - }, function onprogress() { - - }, function onerror(err) { - console.warn(err); - }); - // window.loader = loader; - // console.log('got filesystem', modelFileUrl, loader); - } else { - throw new Error('no model file in package'); - } + _loadModelFilesystem(filesystem); } else { - throw new Error('unknown file type'); + throw new Error(`unknown file type: ${filename} (${fileType})`); } }; @@ -460,7 +525,7 @@

Examples

if (files.length === 1) { const [file] = files; const dataUrl = URL.createObjectURL(file); - _loadModel(dataUrl, file.name); + _loadModelUrl(dataUrl, file.name); } const {parentNode} = inputFileEl; @@ -489,7 +554,7 @@

Examples

const file = e.dataTransfer.items[i].getAsFile(); // console.log('got file', e.dataTransfer.items[i], file); const dataUrl = URL.createObjectURL(file); - _loadModel(dataUrl, file.name); + _loadModelUrl(dataUrl, file.name); } } }); @@ -517,10 +582,10 @@

Examples

e.preventDefault(); const {href} = aAvatar; - _loadModel(href); + _loadModelUrl(href); }); } -_loadModel(aAvatars[0].href); +_loadModelUrl(aAvatars[0].href); const realDateNow = (now => () => now())(Date.now);//() => 2000; function animate() { diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index bc7811b..e732bce 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -28,7 +28,24 @@ class Rig { } }); - const tailBones = skeleton.bones.filter(bone => bone.children.length === 0); + const _getTailBones = skeleton => { + const result = []; + const _recurse = bones => { + for (let i = 0; i < bones.length; i++) { + const bone = bones[i]; + if (bone.children.length === 0) { + if (!result.includes(bone)) { + result.push(bone); + } + } else { + _recurse(bone.children); + } + } + }; + _recurse(skeleton.bones); + return result; + }; + const tailBones = _getTailBones(skeleton); const _findClosestParentBone = (bone, pred) => { for (; bone; bone = bone.parent) { if (pred(bone)) { @@ -77,6 +94,22 @@ class Rig { } return result; }; + const _findHead = () => { + const headBones = tailBones.map(tailBone => { + const headBone = _findFurthestParentBone(tailBone, bone => /head/i.test(bone.name)); + if (headBone) { + return headBone; + } else { + return null; + } + }).filter(bone => bone); + const headBone = headBones.length > 0 ? headBones[0] : null; + if (headBone) { + return headBone; + } else { + return null; + } + }; const _findEye = left => { const regexp = left ? /l/i : /r/i; const eyeBones = tailBones.map(tailBone => { @@ -197,9 +230,9 @@ class Rig { return null; } }; - const Eye_L = _findEye(true); - const Eye_R = _findEye(false); - const Head = Eye_L.parent; + // const Eye_L = _findEye(true); + // const Eye_R = _findEye(false); + const Head = _findHead(); const Neck = Head.parent; const Chest = Neck.parent; const Hips = _findHips(); @@ -225,8 +258,8 @@ class Rig { Chest, Neck, Head, - Eye_L, - Eye_R, + /* Eye_L, + Eye_R, */ Left_shoulder, Left_arm, @@ -256,11 +289,24 @@ class Rig { }; const armature = _findArmature(Hips); - const eyeDirection = modelBones.Eye_L.getWorldPosition(new Vector3()).sub(modelBones.Head.getWorldPosition(new Vector3())); - let flipZ = eyeDirection.z < 0; + const eyeOffset = (() => { + const Eye_L = _findEye(true); + const Eye_R = _findEye(false); + if (Eye_L && Eye_R) { + return Eye_L.getWorldPosition(new Vector3()).sub(Head.getWorldPosition(new Vector3())); + } else { + const headChild =_traverseChild(Head, 1); + if (headChild) { + return headChild.getWorldPosition(new Vector3()).sub(Head.getWorldPosition(new Vector3())); + } else { + return new Vector3(0, 0, 1); + } + } + })(); + let flipZ = eyeOffset.z < 0; const armatureDirection = new THREE.Vector3(0, 1, 0).applyQuaternion(armature.quaternion); const flipY = armatureDirection.z < -0.5; - console.log('flip', flipZ, flipY, eyeDirection.toArray().join(','), armatureDirection.toArray().join(',')); + console.log('flip', flipZ, flipY, eyeOffset.toArray().join(','), armatureDirection.toArray().join(',')); this.flipZ = flipZ; this.flipY = flipY; @@ -333,20 +379,20 @@ class Rig { }); const _getOffset = (bone, parent = bone.parent) => bone.getWorldPosition(new Vector3()).sub(parent.getWorldPosition(new Vector3())); - const _averagePoint = points => { + /* const _averagePoint = points => { const result = new Vector3(); for (let i = 0; i < points.length; i++) { result.add(points[i]); } result.divideScalar(points.length); return result; - }; + }; */ const setups = { spine: _getOffset(modelBones.Spine), hips: _getOffset(modelBones.Spine, modelBones.Head), neck: _getOffset(modelBones.Neck), head: _getOffset(modelBones.Head), - eyes: _averagePoint([_getOffset(modelBones.Eye_L), _getOffset(modelBones.Eye_R)]), + eyes: eyeOffset, leftShoulder: _getOffset(modelBones.Right_shoulder), leftUpperArm: _getOffset(modelBones.Right_arm), From 25ca671ae57ca6192e4f8288920ca665e6c7d7be Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 23 Oct 2019 03:06:20 -0400 Subject: [PATCH 218/562] Add model4.zip example --- vrarmik.html | 1 + 1 file changed, 1 insertion(+) diff --git a/vrarmik.html b/vrarmik.html index c873bc1..e4d11fd 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -228,6 +228,7 @@

Examples

model.glb
model2.vrm
model3.unitypackage
+ model4.zip

+
From 049ad17dcbe879f605e591ad7f3298dcc91cdb53 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 04:33:22 -0400 Subject: [PATCH 277/562] Add make text mesh render helper --- vrarmik.html | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/vrarmik.html b/vrarmik.html index 82e86cc..dfb384e 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -299,6 +299,46 @@

Examples

} return mesh; }; +const _makeTextMesh = (s = '', color = 0x000000, size = 1) => { + // create a geometry of packed bitmap glyphs, + // word wrapped to 300px and right-aligned + var geometry = createTextGeometry({ + width: Infinity, + font: fontJson, + }); + + // change text and other options as desired + // the options sepcified in constructor will + // be used as defaults + geometry.update(s); + + // the resulting layout has metrics and bounds + // console.log(geometry.layout.height) + // console.log(geometry.layout.descender) + + var material = new THREE.RawShaderMaterial(createSDFShader({ + map: fontTexture, + transparent: true, + color, + // color: palette[Math.floor(Math.random() * palette.length)] + // negate: false, + side: THREE.DoubleSide, + })); + + const scaleFactor = 0.002 * size; + + const mesh = new THREE.Mesh(geometry, material) + mesh.position.set(0, -geometry.layout.lineHeight * 0.001, 0); + mesh.scale.set(scaleFactor, -scaleFactor, -scaleFactor); + mesh.getText = () => s; + mesh.setText = newS => { + if (newS !== s) { + s = newS; + geometry.update(s); + } + }; + return mesh; +}; const meshes = { eyes: _makeCubeMesh(0xFF0000), head: _makeCubeMesh(0xFF8080), From 9fa319ad1738889c207ee0d76b8c79ab5458db81 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 04:34:01 -0400 Subject: [PATCH 278/562] Small avatars links cleanup --- vrarmik.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index dfb384e..dabc640 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -697,7 +697,7 @@

Examples

orbitControls.enableMiddleZoom = false; orbitControls.update(); -const aAvatars = document.querySelectorAll('.a-avatar'); +const aAvatars = Array.from(document.querySelectorAll('.a-avatar')); for (let i = 0; i < aAvatars.length; i++) { const aAvatar = aAvatars[i]; aAvatar.addEventListener('click', e => { From 52f569e00cc80ebeb28b02a957b3f13e4ae3dd78 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 04:35:56 -0400 Subject: [PATCH 279/562] Add missing webxr polyfill sources --- HelioWebXRPolyfill.js | 192 ++ webxr-polyfill.module.js | 6139 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 6331 insertions(+) create mode 100644 HelioWebXRPolyfill.js create mode 100644 webxr-polyfill.module.js diff --git a/HelioWebXRPolyfill.js b/HelioWebXRPolyfill.js new file mode 100644 index 0000000..ffa81eb --- /dev/null +++ b/HelioWebXRPolyfill.js @@ -0,0 +1,192 @@ +/** + * @author mvilledieu / http://github.com/mvilledieu + */ + +if ( /(Helio)/g.test( navigator.userAgent ) && "xr" in navigator ) { + + console.log( "Helio WebXR Polyfill (Lumin 0.97.0)" ); + + const isHelio96 = navigator.userAgent.includes("Chrome/73"); + + // WebXRManager - XR.supportSession() Polyfill - WebVR.js line 147 + + if ( + "supportsSession" in navigator.xr === false && + "supportsSessionMode" in navigator.xr + ) { + + navigator.xr.supportsSession = function ( sessionType ) { + + // Force using immersive-ar + return navigator.xr.supportsSessionMode( 'immersive-ar' ); + + }; + + } + + if ( "requestSession" in navigator.xr ) { + + const tempRequestSession = navigator.xr.requestSession.bind( navigator.xr ); + + navigator.xr.requestSession = function ( sessionType ) { + + return new Promise( function ( resolve, reject ) { + + const sessionType = (isHelio96 ? { + mode: 'immersive-ar' // Force using immersive-ar + } : 'immersive-ar'); + + tempRequestSession( sessionType ) + .then( function ( session ) { + + // WebXRManager - xrFrame.getPose() Polyfill - line 279 + + const tempRequestAnimationFrame = session.requestAnimationFrame.bind( + session + ); + + session.requestAnimationFrame = function ( callback ) { + + return tempRequestAnimationFrame( function ( time, frame ) { + + // WebXRManager - xrFrame.getViewerPose() Polyfill - line 279 + // Transforms view.viewMatrix to view.transform.inverse.matrix + + const tempGetViewerPose = frame.getViewerPose.bind( frame ); + + frame.getViewerPose = function ( referenceSpace ) { + + const pose = tempGetViewerPose( referenceSpace ); + + pose.views.forEach( function ( view ) { + + view.transform = { + inverse: { + matrix: view.viewMatrix + } + }; + + } ); + + return pose; + + }; + + // WebXRManager - xrFrame.getPose() Polyfill - line 259 + + const tempGetPose = (isHelio96 ? null : frame.getPose.bind( frame )); + + frame.getPose = function ( targetRaySpace, referenceSpace ) { + + if (isHelio96) { + + const inputPose = frame.getInputPose( + targetRaySpace, + referenceSpace + ); + + inputPose.transform = { + matrix: inputPose.targetRay.transformMatrix + }; + + return inputPose; + + } else { + + return tempGetPose(targetRaySpace.gripSpace, referenceSpace); + + } + + }; + + callback( time, frame ); + + } ); + + }; + + // WebXRManager - xrFrame.getPose( inputSource.targetRaySpace, referenceSpace) Polyfill - line 279 + + const tempGetInputSources = session.getInputSources.bind( session ); + + session.getInputSources = function () { + + const res = tempGetInputSources(); + + res.forEach( function (xrInputSource ) { + + if (!('targetRaySpace' in xrInputSource)) { + Object.defineProperty( xrInputSource, "targetRaySpace", { + get: function () { + + return xrInputSource; + + } + } ); + } + + } ); + + return res; + + }; + + // WebXRManager - xrSession.getInputSources() Polyfill Line 132 - 136 + + /* session.inputSources = */Object.defineProperty( + session, + "inputSources", + { + get: session.getInputSources + } + ); + + // WebXRManager - xrSession.updateRenderState() Polyfill Line 129 + + if (isHelio96) { + + session.updateRenderState = function ( { baseLayer } ) { + + session.baseLayer = baseLayer; + + // WebXRManager - xrSession.renderState.baseLayer Polyfill Line 219 + + session.renderState = { + baseLayer: baseLayer + }; + + }; + + } + + // WebXRManager - xrSession.requestReferenceSpace() Polyfill Line 130 + + const tempRequestReferenceSpace = session.requestReferenceSpace.bind( + session + ); + + session.requestReferenceSpace = function () { + + return tempRequestReferenceSpace( { + type: "stationary", + subtype: "floor-level" + } ); + + }; + + resolve( session ); + + } ) + .catch( function ( error ) { + + return reject( error ); + + } ); + + } ); + + }; + + } + +} diff --git a/webxr-polyfill.module.js b/webxr-polyfill.module.js new file mode 100644 index 0000000..017698d --- /dev/null +++ b/webxr-polyfill.module.js @@ -0,0 +1,6139 @@ +/** + * @license + * webxr-polyfill + * Copyright (c) 2017 Google + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @license + * cardboard-vr-display + * Copyright (c) 2015-2017 Google + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @license + * webvr-polyfill-dpdb + * Copyright (c) 2017 Google + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @license + * wglu-preserve-state + * Copyright (c) 2016, Brandon Jones. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +/** + * @license + * nosleep.js + * Copyright (c) 2017, Rich Tibbett + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +if (!/(Helio)/g.test(navigator.userAgent)) { + +const _global = typeof global !== 'undefined' ? global : + typeof self !== 'undefined' ? self : + typeof window !== 'undefined' ? window : {}; + +const PRIVATE = Symbol('@@webxr-polyfill/EventTarget'); +class EventTarget { + constructor() { + this[PRIVATE] = { + listeners: new Map(), + }; + } + addEventListener(type, listener) { + if (typeof type !== 'string') { throw new Error('`type` must be a string'); } + if (typeof listener !== 'function') { throw new Error('`listener` must be a function'); } + const typedListeners = this[PRIVATE].listeners.get(type) || []; + typedListeners.push(listener); + this[PRIVATE].listeners.set(type, typedListeners); + } + removeEventListener(type, listener) { + if (typeof type !== 'string') { throw new Error('`type` must be a string'); } + if (typeof listener !== 'function') { throw new Error('`listener` must be a function'); } + const typedListeners = this[PRIVATE].listeners.get(type) || []; + for (let i = typedListeners.length; i >= 0; i--) { + if (typedListeners[i] === listener) { + typedListeners.pop(); + } + } + } + dispatchEvent(type, event) { + const typedListeners = this[PRIVATE].listeners.get(type) || []; + const queue = []; + for (let i = 0; i < typedListeners.length; i++) { + queue[i] = typedListeners[i]; + } + for (let listener of queue) { + listener(event); + } + if (typeof this[`on${type}`] === 'function') { + this[`on${type}`](event); + } + } +} + +const PRIVATE$1 = Symbol('@@webxr-polyfill/XR'); +const XRSessionModes = ['inline', 'immersive-vr', 'immersive-ar']; +const POLYFILL_REQUEST_SESSION_ERROR = +`Polyfill Error: Must call navigator.xr.supportsSession() with any XRSessionMode +or navigator.xr.requestSession('inline') prior to requesting an immersive +session. This is a limitation specific to the WebXR Polyfill and does not apply +to native implementations of the API.`; +class XR$1 extends EventTarget { + constructor(devicePromise) { + super(); + this[PRIVATE$1] = { + device: null, + devicePromise, + immersiveSession: null, + inlineSessions: new Set(), + }; + devicePromise.then((device) => { this[PRIVATE$1].device = device; }); + } + async supportsSession(mode) { + if (!this[PRIVATE$1].device) { + await this[PRIVATE$1].devicePromise; + } + if (mode != 'inline') { + if (!this[PRIVATE$1].device.supportsSession(mode)) { + return Promise.reject(null); + } + } + return Promise.resolve(null); + } + async requestSession(mode) { + if (!this[PRIVATE$1].device) { + if (mode != 'inline') { + throw new Error(POLYFILL_REQUEST_SESSION_ERROR); + } else { + await this[PRIVATE$1].devicePromise; + } + } + const sessionId = await this[PRIVATE$1].device.requestSession(mode); + const session = new XRSession(this[PRIVATE$1].device, mode, sessionId); + if (mode == 'inline') { + this[PRIVATE$1].inlineSessions.add(session); + } else { + this[PRIVATE$1].immersiveSession = session; + } + const onSessionEnd = () => { + if (mode == 'inline') { + this[PRIVATE$1].inlineSessions.delete(session); + } else { + this[PRIVATE$1].immersiveSession = null; + } + session.removeEventListener('end', onSessionEnd); + }; + session.addEventListener('end', onSessionEnd); + return session; + } +} + +let now; +if ('performance' in _global === false) { + let startTime = Date.now(); + now = () => Date.now() - startTime; +} else { + now = () => performance.now(); +} +var now$1 = now; + +const PRIVATE$2 = Symbol('@@webxr-polyfill/XRPose'); +class XRPose$1 { + constructor(transform, emulatedPosition) { + this[PRIVATE$2] = { + transform, + emulatedPosition, + }; + } + get transform() { return this[PRIVATE$2].transform; } + get emulatedPosition() { return this[PRIVATE$2].emulatedPosition; } + _setTransform(transform) { this[PRIVATE$2].transform = transform; } +} + +const EPSILON = 0.000001; +let ARRAY_TYPE = (typeof Float32Array !== 'undefined') ? Float32Array : Array; + + +const degree = Math.PI / 180; + +function create() { + let out = new ARRAY_TYPE(16); + if(ARRAY_TYPE != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + } + out[0] = 1; + out[5] = 1; + out[10] = 1; + out[15] = 1; + return out; +} + +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} + + +function identity(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} + +function invert(out, a) { + let a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3]; + let a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7]; + let a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11]; + let a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15]; + let b00 = a00 * a11 - a01 * a10; + let b01 = a00 * a12 - a02 * a10; + let b02 = a00 * a13 - a03 * a10; + let b03 = a01 * a12 - a02 * a11; + let b04 = a01 * a13 - a03 * a11; + let b05 = a02 * a13 - a03 * a12; + let b06 = a20 * a31 - a21 * a30; + let b07 = a20 * a32 - a22 * a30; + let b08 = a20 * a33 - a23 * a30; + let b09 = a21 * a32 - a22 * a31; + let b10 = a21 * a33 - a23 * a31; + let b11 = a22 * a33 - a23 * a32; + let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (!det) { + return null; + } + det = 1.0 / det; + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + return out; +} + + +function multiply(out, a, b) { + let a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3]; + let a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7]; + let a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11]; + let a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15]; + let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3]; + out[0] = b0*a00 + b1*a10 + b2*a20 + b3*a30; + out[1] = b0*a01 + b1*a11 + b2*a21 + b3*a31; + out[2] = b0*a02 + b1*a12 + b2*a22 + b3*a32; + out[3] = b0*a03 + b1*a13 + b2*a23 + b3*a33; + b0 = b[4]; b1 = b[5]; b2 = b[6]; b3 = b[7]; + out[4] = b0*a00 + b1*a10 + b2*a20 + b3*a30; + out[5] = b0*a01 + b1*a11 + b2*a21 + b3*a31; + out[6] = b0*a02 + b1*a12 + b2*a22 + b3*a32; + out[7] = b0*a03 + b1*a13 + b2*a23 + b3*a33; + b0 = b[8]; b1 = b[9]; b2 = b[10]; b3 = b[11]; + out[8] = b0*a00 + b1*a10 + b2*a20 + b3*a30; + out[9] = b0*a01 + b1*a11 + b2*a21 + b3*a31; + out[10] = b0*a02 + b1*a12 + b2*a22 + b3*a32; + out[11] = b0*a03 + b1*a13 + b2*a23 + b3*a33; + b0 = b[12]; b1 = b[13]; b2 = b[14]; b3 = b[15]; + out[12] = b0*a00 + b1*a10 + b2*a20 + b3*a30; + out[13] = b0*a01 + b1*a11 + b2*a21 + b3*a31; + out[14] = b0*a02 + b1*a12 + b2*a22 + b3*a32; + out[15] = b0*a03 + b1*a13 + b2*a23 + b3*a33; + return out; +} + + + + + + + + + + + + +function fromRotationTranslation(out, q, v) { + let x = q[0], y = q[1], z = q[2], w = q[3]; + let x2 = x + x; + let y2 = y + y; + let z2 = z + z; + let xx = x * x2; + let xy = x * y2; + let xz = x * z2; + let yy = y * y2; + let yz = y * z2; + let zz = z * z2; + let wx = w * x2; + let wy = w * y2; + let wz = w * z2; + out[0] = 1 - (yy + zz); + out[1] = xy + wz; + out[2] = xz - wy; + out[3] = 0; + out[4] = xy - wz; + out[5] = 1 - (xx + zz); + out[6] = yz + wx; + out[7] = 0; + out[8] = xz + wy; + out[9] = yz - wx; + out[10] = 1 - (xx + yy); + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} + +function getTranslation(out, mat) { + out[0] = mat[12]; + out[1] = mat[13]; + out[2] = mat[14]; + return out; +} + +function getRotation(out, mat) { + let trace = mat[0] + mat[5] + mat[10]; + let S = 0; + if (trace > 0) { + S = Math.sqrt(trace + 1.0) * 2; + out[3] = 0.25 * S; + out[0] = (mat[6] - mat[9]) / S; + out[1] = (mat[8] - mat[2]) / S; + out[2] = (mat[1] - mat[4]) / S; + } else if ((mat[0] > mat[5]) && (mat[0] > mat[10])) { + S = Math.sqrt(1.0 + mat[0] - mat[5] - mat[10]) * 2; + out[3] = (mat[6] - mat[9]) / S; + out[0] = 0.25 * S; + out[1] = (mat[1] + mat[4]) / S; + out[2] = (mat[8] + mat[2]) / S; + } else if (mat[5] > mat[10]) { + S = Math.sqrt(1.0 + mat[5] - mat[0] - mat[10]) * 2; + out[3] = (mat[8] - mat[2]) / S; + out[0] = (mat[1] + mat[4]) / S; + out[1] = 0.25 * S; + out[2] = (mat[6] + mat[9]) / S; + } else { + S = Math.sqrt(1.0 + mat[10] - mat[0] - mat[5]) * 2; + out[3] = (mat[1] - mat[4]) / S; + out[0] = (mat[8] + mat[2]) / S; + out[1] = (mat[6] + mat[9]) / S; + out[2] = 0.25 * S; + } + return out; +} + + + + +function perspective(out, fovy, aspect, near, far) { + let f = 1.0 / Math.tan(fovy / 2), nf; + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + nf = 1 / (near - far); + out[10] = (far + near) * nf; + out[14] = (2 * far * near) * nf; + } else { + out[10] = -1; + out[14] = -2 * near; + } + return out; +} + +function create$1() { + let out = new ARRAY_TYPE(3); + if(ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + return out; +} +function clone$1(a) { + var out = new ARRAY_TYPE(3); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} +function length(a) { + let x = a[0]; + let y = a[1]; + let z = a[2]; + return Math.sqrt(x*x + y*y + z*z); +} +function fromValues$1(x, y, z) { + let out = new ARRAY_TYPE(3); + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} +function copy$1(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} + +function add$1(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + return out; +} + + + + + + + + +function scale$1(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + return out; +} + + + + + + +function normalize(out, a) { + let x = a[0]; + let y = a[1]; + let z = a[2]; + let len = x*x + y*y + z*z; + if (len > 0) { + len = 1 / Math.sqrt(len); + out[0] = a[0] * len; + out[1] = a[1] * len; + out[2] = a[2] * len; + } + return out; +} +function dot(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} +function cross(out, a, b) { + let ax = a[0], ay = a[1], az = a[2]; + let bx = b[0], by = b[1], bz = b[2]; + out[0] = ay * bz - az * by; + out[1] = az * bx - ax * bz; + out[2] = ax * by - ay * bx; + return out; +} + + + + + + +function transformQuat(out, a, q) { + let qx = q[0], qy = q[1], qz = q[2], qw = q[3]; + let x = a[0], y = a[1], z = a[2]; + let uvx = qy * z - qz * y, + uvy = qz * x - qx * z, + uvz = qx * y - qy * x; + let uuvx = qy * uvz - qz * uvy, + uuvy = qz * uvx - qx * uvz, + uuvz = qx * uvy - qy * uvx; + let w2 = qw * 2; + uvx *= w2; + uvy *= w2; + uvz *= w2; + uuvx *= 2; + uuvy *= 2; + uuvz *= 2; + out[0] = x + uvx + uuvx; + out[1] = y + uvy + uuvy; + out[2] = z + uvz + uuvz; + return out; +} + + + +function angle(a, b) { + let tempA = fromValues$1(a[0], a[1], a[2]); + let tempB = fromValues$1(b[0], b[1], b[2]); + normalize(tempA, tempA); + normalize(tempB, tempB); + let cosine = dot(tempA, tempB); + if(cosine > 1.0) { + return 0; + } + else if(cosine < -1.0) { + return Math.PI; + } else { + return Math.acos(cosine); + } +} + + + + + + + + +const len = length; + +const forEach = (function() { + let vec = create$1(); + return function(a, stride, offset, count, fn, arg) { + let i, l; + if(!stride) { + stride = 3; + } + if(!offset) { + offset = 0; + } + if(count) { + l = Math.min((count * stride) + offset, a.length); + } else { + l = a.length; + } + for(i = offset; i < l; i += stride) { + vec[0] = a[i]; vec[1] = a[i+1]; vec[2] = a[i+2]; + fn(vec, vec, arg); + a[i] = vec[0]; a[i+1] = vec[1]; a[i+2] = vec[2]; + } + return a; + }; +})(); + +function create$2() { + let out = new ARRAY_TYPE(9); + if(ARRAY_TYPE != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[5] = 0; + out[6] = 0; + out[7] = 0; + } + out[0] = 1; + out[4] = 1; + out[8] = 1; + return out; +} + +function create$3() { + let out = new ARRAY_TYPE(4); + if(ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + } + return out; +} +function clone$3(a) { + let out = new ARRAY_TYPE(4); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} +function fromValues$3(x, y, z, w) { + let out = new ARRAY_TYPE(4); + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = w; + return out; +} +function copy$3(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} + + + + + + + + + + + + + + + + + + +function normalize$1(out, a) { + let x = a[0]; + let y = a[1]; + let z = a[2]; + let w = a[3]; + let len = x*x + y*y + z*z + w*w; + if (len > 0) { + len = 1 / Math.sqrt(len); + out[0] = x * len; + out[1] = y * len; + out[2] = z * len; + out[3] = w * len; + } + return out; +} + + + + + + + + + + + + + + + +const forEach$1 = (function() { + let vec = create$3(); + return function(a, stride, offset, count, fn, arg) { + let i, l; + if(!stride) { + stride = 4; + } + if(!offset) { + offset = 0; + } + if(count) { + l = Math.min((count * stride) + offset, a.length); + } else { + l = a.length; + } + for(i = offset; i < l; i += stride) { + vec[0] = a[i]; vec[1] = a[i+1]; vec[2] = a[i+2]; vec[3] = a[i+3]; + fn(vec, vec, arg); + a[i] = vec[0]; a[i+1] = vec[1]; a[i+2] = vec[2]; a[i+3] = vec[3]; + } + return a; + }; +})(); + +function create$4() { + let out = new ARRAY_TYPE(4); + if(ARRAY_TYPE != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + out[3] = 1; + return out; +} + +function setAxisAngle(out, axis, rad) { + rad = rad * 0.5; + let s = Math.sin(rad); + out[0] = s * axis[0]; + out[1] = s * axis[1]; + out[2] = s * axis[2]; + out[3] = Math.cos(rad); + return out; +} + +function multiply$4(out, a, b) { + let ax = a[0], ay = a[1], az = a[2], aw = a[3]; + let bx = b[0], by = b[1], bz = b[2], bw = b[3]; + out[0] = ax * bw + aw * bx + ay * bz - az * by; + out[1] = ay * bw + aw * by + az * bx - ax * bz; + out[2] = az * bw + aw * bz + ax * by - ay * bx; + out[3] = aw * bw - ax * bx - ay * by - az * bz; + return out; +} + + + + +function slerp(out, a, b, t) { + let ax = a[0], ay = a[1], az = a[2], aw = a[3]; + let bx = b[0], by = b[1], bz = b[2], bw = b[3]; + let omega, cosom, sinom, scale0, scale1; + cosom = ax * bx + ay * by + az * bz + aw * bw; + if ( cosom < 0.0 ) { + cosom = -cosom; + bx = - bx; + by = - by; + bz = - bz; + bw = - bw; + } + if ( (1.0 - cosom) > EPSILON ) { + omega = Math.acos(cosom); + sinom = Math.sin(omega); + scale0 = Math.sin((1.0 - t) * omega) / sinom; + scale1 = Math.sin(t * omega) / sinom; + } else { + scale0 = 1.0 - t; + scale1 = t; + } + out[0] = scale0 * ax + scale1 * bx; + out[1] = scale0 * ay + scale1 * by; + out[2] = scale0 * az + scale1 * bz; + out[3] = scale0 * aw + scale1 * bw; + return out; +} + +function invert$2(out, a) { + let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3]; + let dot$$1 = a0*a0 + a1*a1 + a2*a2 + a3*a3; + let invDot = dot$$1 ? 1.0/dot$$1 : 0; + out[0] = -a0*invDot; + out[1] = -a1*invDot; + out[2] = -a2*invDot; + out[3] = a3*invDot; + return out; +} + +function fromMat3(out, m) { + let fTrace = m[0] + m[4] + m[8]; + let fRoot; + if ( fTrace > 0.0 ) { + fRoot = Math.sqrt(fTrace + 1.0); + out[3] = 0.5 * fRoot; + fRoot = 0.5/fRoot; + out[0] = (m[5]-m[7])*fRoot; + out[1] = (m[6]-m[2])*fRoot; + out[2] = (m[1]-m[3])*fRoot; + } else { + let i = 0; + if ( m[4] > m[0] ) + i = 1; + if ( m[8] > m[i*3+i] ) + i = 2; + let j = (i+1)%3; + let k = (i+2)%3; + fRoot = Math.sqrt(m[i*3+i]-m[j*3+j]-m[k*3+k] + 1.0); + out[i] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[3] = (m[j*3+k] - m[k*3+j]) * fRoot; + out[j] = (m[j*3+i] + m[i*3+j]) * fRoot; + out[k] = (m[k*3+i] + m[i*3+k]) * fRoot; + } + return out; +} +function fromEuler(out, x, y, z) { + let halfToRad = 0.5 * Math.PI / 180.0; + x *= halfToRad; + y *= halfToRad; + z *= halfToRad; + let sx = Math.sin(x); + let cx = Math.cos(x); + let sy = Math.sin(y); + let cy = Math.cos(y); + let sz = Math.sin(z); + let cz = Math.cos(z); + out[0] = sx * cy * cz - cx * sy * sz; + out[1] = cx * sy * cz + sx * cy * sz; + out[2] = cx * cy * sz - sx * sy * cz; + out[3] = cx * cy * cz + sx * sy * sz; + return out; +} + +const clone$4 = clone$3; +const fromValues$4 = fromValues$3; +const copy$4 = copy$3; + + + + + + + + + + +const normalize$2 = normalize$1; + + +const rotationTo = (function() { + let tmpvec3 = create$1(); + let xUnitVec3 = fromValues$1(1,0,0); + let yUnitVec3 = fromValues$1(0,1,0); + return function(out, a, b) { + let dot$$1 = dot(a, b); + if (dot$$1 < -0.999999) { + cross(tmpvec3, xUnitVec3, a); + if (len(tmpvec3) < 0.000001) + cross(tmpvec3, yUnitVec3, a); + normalize(tmpvec3, tmpvec3); + setAxisAngle(out, tmpvec3, Math.PI); + return out; + } else if (dot$$1 > 0.999999) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; + } else { + cross(tmpvec3, a, b); + out[0] = tmpvec3[0]; + out[1] = tmpvec3[1]; + out[2] = tmpvec3[2]; + out[3] = 1 + dot$$1; + return normalize$2(out, out); + } + }; +})(); +const sqlerp = (function () { + let temp1 = create$4(); + let temp2 = create$4(); + return function (out, a, b, c, d, t) { + slerp(temp1, a, d, t); + slerp(temp2, b, c, t); + slerp(out, temp1, temp2, 2 * t * (1 - t)); + return out; + }; +}()); +const setAxes = (function() { + let matr = create$2(); + return function(out, view, right, up) { + matr[0] = right[0]; + matr[3] = right[1]; + matr[6] = right[2]; + matr[1] = up[0]; + matr[4] = up[1]; + matr[7] = up[2]; + matr[2] = -view[0]; + matr[5] = -view[1]; + matr[8] = -view[2]; + return normalize$2(out, fromMat3(out, matr)); + }; +})(); + +const PRIVATE$3 = Symbol('@@webxr-polyfill/XRRigidTransform'); +class XRRigidTransform$1 { + constructor() { + this[PRIVATE$3] = { + matrix: null, + position: null, + orientation: null, + inverse: null, + }; + if (arguments.length === 0) { + this[PRIVATE$3].matrix = identity(new Float32Array(16)); + } else if (arguments.length === 1) { + if (arguments[0] instanceof Float32Array) { + this[PRIVATE$3].matrix = arguments[0]; + } else { + this[PRIVATE$3].position = this._getPoint(arguments[0]); + this[PRIVATE$3].orientation = DOMPointReadOnly.fromPoint({ + x: 0, y: 0, z: 0, w: 1 + }); + } + } else if (arguments.length === 2) { + this[PRIVATE$3].position = this._getPoint(arguments[0]); + this[PRIVATE$3].orientation = this._getPoint(arguments[1]); + } else { + throw new Error("Too many arguments!"); + } + if (this[PRIVATE$3].matrix) { + let position = create$1(); + getTranslation(position, this[PRIVATE$3].matrix); + this[PRIVATE$3].position = DOMPointReadOnly.fromPoint({ + x: position[0], + y: position[1], + z: position[2] + }); + let orientation = create$4(); + getRotation(orientation, this[PRIVATE$3].matrix); + this[PRIVATE$3].orientation = DOMPointReadOnly.fromPoint({ + x: orientation[0], + y: orientation[1], + z: orientation[2], + w: orientation[3] + }); + } else { + this[PRIVATE$3].matrix = identity(new Float32Array(16)); + fromRotationTranslation( + this[PRIVATE$3].matrix, + fromValues$4( + this[PRIVATE$3].orientation.x, + this[PRIVATE$3].orientation.y, + this[PRIVATE$3].orientation.z, + this[PRIVATE$3].orientation.w), + fromValues$1( + this[PRIVATE$3].position.x, + this[PRIVATE$3].position.y, + this[PRIVATE$3].position.z) + ); + } + } + _getPoint(arg) { + if (arg instanceof DOMPointReadOnly) { + return arg; + } + return DOMPointReadOnly.fromPoint(arg); + } + get matrix() { return this[PRIVATE$3].matrix; } + get position() { return this[PRIVATE$3].position; } + get orientation() { return this[PRIVATE$3].orientation; } + get inverse() { + if (this[PRIVATE$3].inverse === null) { + let invMatrix = identity(new Float32Array(16)); + invert(invMatrix, this[PRIVATE$3].matrix); + this[PRIVATE$3].inverse = new XRRigidTransform$1(invMatrix); + this[PRIVATE$3].inverse[PRIVATE$3].inverse = this; + } + return this[PRIVATE$3].inverse; + } +} + +const PRIVATE$4 = Symbol('@@webxr-polyfill/XRViewerPose'); +class XRViewerPose extends XRPose$1 { + constructor(device, views) { + super(new XRRigidTransform$1(), false); + this[PRIVATE$4] = { + device, + views, + leftViewMatrix: identity(new Float32Array(16)), + rightViewMatrix: identity(new Float32Array(16)), + poseModelMatrix: identity(new Float32Array(16)), + }; + } + get poseModelMatrix() { return this[PRIVATE$4].poseModelMatrix; } + get views() { + return this[PRIVATE$4].views; + } + _updateFromReferenceSpace(refSpace) { + const pose = this[PRIVATE$4].device.getBasePoseMatrix(); + const leftViewMatrix = this[PRIVATE$4].device.getBaseViewMatrix('left'); + const rightViewMatrix = this[PRIVATE$4].device.getBaseViewMatrix('right'); + if (pose) { + refSpace._transformBasePoseMatrix(this[PRIVATE$4].poseModelMatrix, pose); + refSpace._adjustForOriginOffset(this[PRIVATE$4].poseModelMatrix); + super._setTransform(new XRRigidTransform$1(this[PRIVATE$4].poseModelMatrix)); + } + if (leftViewMatrix) { + refSpace._transformBaseViewMatrix( + this[PRIVATE$4].leftViewMatrix, + leftViewMatrix, + this[PRIVATE$4].poseModelMatrix); + multiply( + this[PRIVATE$4].leftViewMatrix, + this[PRIVATE$4].leftViewMatrix, + refSpace._originOffsetMatrix()); + } + if (rightViewMatrix) { + refSpace._transformBaseViewMatrix( + this[PRIVATE$4].rightViewMatrix, + rightViewMatrix, + this[PRIVATE$4].poseModelMatrix); + multiply( + this[PRIVATE$4].rightViewMatrix, + this[PRIVATE$4].rightViewMatrix, + refSpace._originOffsetMatrix()); + } + for (let view of this[PRIVATE$4].views) { + if (view.eye == "left") { + view._updateViewMatrix(this[PRIVATE$4].leftViewMatrix); + } else if (view.eye == "right") { + view._updateViewMatrix(this[PRIVATE$4].rightViewMatrix); + } + } + } +} + +const PRIVATE$5 = Symbol('@@webxr-polyfill/XRViewport'); +class XRViewport { + constructor(target) { + this[PRIVATE$5] = { target }; + } + get x() { return this[PRIVATE$5].target.x; } + get y() { return this[PRIVATE$5].target.y; } + get width() { return this[PRIVATE$5].target.width; } + get height() { return this[PRIVATE$5].target.height; } +} + +const XREyes = ['left', 'right']; +const PRIVATE$6 = Symbol('@@webxr-polyfill/XRView'); +class XRView { + constructor(device, eye, sessionId) { + if (!XREyes.includes(eye)) { + throw new Error(`XREye must be one of: ${XREyes}`); + } + const temp = Object.create(null); + const viewport = new XRViewport(temp); + this[PRIVATE$6] = { + device, + eye, + viewport, + temp, + sessionId, + transform: null, + }; + } + get eye() { return this[PRIVATE$6].eye; } + get projectionMatrix() { return this[PRIVATE$6].device.getProjectionMatrix(this.eye); } + get transform() { return this[PRIVATE$6].transform; } + _updateViewMatrix(viewMatrix) { + let invMatrix = identity(new Float32Array(16)); + invert(invMatrix, viewMatrix); + this[PRIVATE$6].transform = new XRRigidTransform$1(invMatrix); + } + _getViewport(layer) { + if (this[PRIVATE$6].device.getViewport(this[PRIVATE$6].sessionId, + this.eye, + layer, + this[PRIVATE$6].temp)) { + return this[PRIVATE$6].viewport; + } + return undefined; + } +} + +var EPSILON$1 = 0.000001; +var ARRAY_TYPE$1 = typeof Float32Array !== 'undefined' ? Float32Array : Array; + + +var degree$1 = Math.PI / 180; + +function create$7() { + var out = new ARRAY_TYPE$1(9); + if (ARRAY_TYPE$1 != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[5] = 0; + out[6] = 0; + out[7] = 0; + } + out[0] = 1; + out[4] = 1; + out[8] = 1; + return out; +} + +function create$9() { + var out = new ARRAY_TYPE$1(3); + if (ARRAY_TYPE$1 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + return out; +} + +function length$3(a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + return Math.sqrt(x * x + y * y + z * z); +} +function fromValues$9(x, y, z) { + var out = new ARRAY_TYPE$1(3); + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} + + + + + + + + + + + + + + + + + + +function normalize$3(out, a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + var len = x * x + y * y + z * z; + if (len > 0) { + len = 1 / Math.sqrt(len); + out[0] = a[0] * len; + out[1] = a[1] * len; + out[2] = a[2] * len; + } + return out; +} +function dot$3(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} +function cross$1(out, a, b) { + var ax = a[0], + ay = a[1], + az = a[2]; + var bx = b[0], + by = b[1], + bz = b[2]; + out[0] = ay * bz - az * by; + out[1] = az * bx - ax * bz; + out[2] = ax * by - ay * bx; + return out; +} + + + + + + + + + + + + + + + + + + + +var len$3 = length$3; + +var forEach$2 = function () { + var vec = create$9(); + return function (a, stride, offset, count, fn, arg) { + var i = void 0, + l = void 0; + if (!stride) { + stride = 3; + } + if (!offset) { + offset = 0; + } + if (count) { + l = Math.min(count * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2]; + fn(vec, vec, arg); + a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2]; + } + return a; + }; +}(); + +function create$10() { + var out = new ARRAY_TYPE$1(4); + if (ARRAY_TYPE$1 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + } + return out; +} + + + + + + + + + + + + + + + + + + + + + +function normalize$4(out, a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + var w = a[3]; + var len = x * x + y * y + z * z + w * w; + if (len > 0) { + len = 1 / Math.sqrt(len); + out[0] = x * len; + out[1] = y * len; + out[2] = z * len; + out[3] = w * len; + } + return out; +} + + + + + + + + + + + + + + + +var forEach$3 = function () { + var vec = create$10(); + return function (a, stride, offset, count, fn, arg) { + var i = void 0, + l = void 0; + if (!stride) { + stride = 4; + } + if (!offset) { + offset = 0; + } + if (count) { + l = Math.min(count * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2];vec[3] = a[i + 3]; + fn(vec, vec, arg); + a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2];a[i + 3] = vec[3]; + } + return a; + }; +}(); + +function create$11() { + var out = new ARRAY_TYPE$1(4); + if (ARRAY_TYPE$1 != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + out[3] = 1; + return out; +} + +function setAxisAngle$1(out, axis, rad) { + rad = rad * 0.5; + var s = Math.sin(rad); + out[0] = s * axis[0]; + out[1] = s * axis[1]; + out[2] = s * axis[2]; + out[3] = Math.cos(rad); + return out; +} + + + + + + +function slerp$1(out, a, b, t) { + var ax = a[0], + ay = a[1], + az = a[2], + aw = a[3]; + var bx = b[0], + by = b[1], + bz = b[2], + bw = b[3]; + var omega = void 0, + cosom = void 0, + sinom = void 0, + scale0 = void 0, + scale1 = void 0; + cosom = ax * bx + ay * by + az * bz + aw * bw; + if (cosom < 0.0) { + cosom = -cosom; + bx = -bx; + by = -by; + bz = -bz; + bw = -bw; + } + if (1.0 - cosom > EPSILON$1) { + omega = Math.acos(cosom); + sinom = Math.sin(omega); + scale0 = Math.sin((1.0 - t) * omega) / sinom; + scale1 = Math.sin(t * omega) / sinom; + } else { + scale0 = 1.0 - t; + scale1 = t; + } + out[0] = scale0 * ax + scale1 * bx; + out[1] = scale0 * ay + scale1 * by; + out[2] = scale0 * az + scale1 * bz; + out[3] = scale0 * aw + scale1 * bw; + return out; +} + + + +function fromMat3$1(out, m) { + var fTrace = m[0] + m[4] + m[8]; + var fRoot = void 0; + if (fTrace > 0.0) { + fRoot = Math.sqrt(fTrace + 1.0); + out[3] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[0] = (m[5] - m[7]) * fRoot; + out[1] = (m[6] - m[2]) * fRoot; + out[2] = (m[1] - m[3]) * fRoot; + } else { + var i = 0; + if (m[4] > m[0]) i = 1; + if (m[8] > m[i * 3 + i]) i = 2; + var j = (i + 1) % 3; + var k = (i + 2) % 3; + fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0); + out[i] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot; + out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot; + out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot; + } + return out; +} + + + + + + + + + + + + + + + +var normalize$5 = normalize$4; + + +var rotationTo$1 = function () { + var tmpvec3 = create$9(); + var xUnitVec3 = fromValues$9(1, 0, 0); + var yUnitVec3 = fromValues$9(0, 1, 0); + return function (out, a, b) { + var dot = dot$3(a, b); + if (dot < -0.999999) { + cross$1(tmpvec3, xUnitVec3, a); + if (len$3(tmpvec3) < 0.000001) cross$1(tmpvec3, yUnitVec3, a); + normalize$3(tmpvec3, tmpvec3); + setAxisAngle$1(out, tmpvec3, Math.PI); + return out; + } else if (dot > 0.999999) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; + } else { + cross$1(tmpvec3, a, b); + out[0] = tmpvec3[0]; + out[1] = tmpvec3[1]; + out[2] = tmpvec3[2]; + out[3] = 1 + dot; + return normalize$5(out, out); + } + }; +}(); +var sqlerp$1 = function () { + var temp1 = create$11(); + var temp2 = create$11(); + return function (out, a, b, c, d, t) { + slerp$1(temp1, a, d, t); + slerp$1(temp2, b, c, t); + slerp$1(out, temp1, temp2, 2 * t * (1 - t)); + return out; + }; +}(); +var setAxes$1 = function () { + var matr = create$7(); + return function (out, view, right, up) { + matr[0] = right[0]; + matr[3] = right[1]; + matr[6] = right[2]; + matr[1] = up[0]; + matr[4] = up[1]; + matr[7] = up[2]; + matr[2] = -view[0]; + matr[5] = -view[1]; + matr[8] = -view[2]; + return normalize$5(out, fromMat3$1(out, matr)); + }; +}(); + +function create$13() { + var out = new ARRAY_TYPE$1(2); + if (ARRAY_TYPE$1 != Float32Array) { + out[0] = 0; + out[1] = 0; + } + return out; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var forEach$4 = function () { + var vec = create$13(); + return function (a, stride, offset, count, fn, arg) { + var i = void 0, + l = void 0; + if (!stride) { + stride = 2; + } + if (!offset) { + offset = 0; + } + if (count) { + l = Math.min(count * stride + offset, a.length); + } else { + l = a.length; + } + for (i = offset; i < l; i += stride) { + vec[0] = a[i];vec[1] = a[i + 1]; + fn(vec, vec, arg); + a[i] = vec[0];a[i + 1] = vec[1]; + } + return a; + }; +}(); + +const PRIVATE$7 = Symbol('@@webxr-polyfill/XRFrame'); +class XRFrame { + constructor(device, session, sessionId) { + const views = [ + new XRView(device, 'left', sessionId), + ]; + if (session.immersive) { + views.push(new XRView(device, 'right', sessionId)); + } + this[PRIVATE$7] = { + device, + viewerPose: new XRViewerPose(device, views), + views, + session, + }; + } + get session() { return this[PRIVATE$7].session; } + getViewerPose(space) { + this[PRIVATE$7].viewerPose._updateFromReferenceSpace(space); + return this[PRIVATE$7].viewerPose; + } + getPose(space, baseSpace) { + if (space._specialType === "viewer") { + let viewerPose = this.getViewerPose(baseSpace); + return new XRPose( + new XRRigidTransform(viewerPose.poseModelMatrix), + viewerPose.emulatedPosition); + } + if (space._specialType === "target-ray" || space._specialType === "grip") { + return this[PRIVATE$7].device.getInputPose( + space._inputSource, baseSpace, space._specialType); + } + return null; + } +} + +const PRIVATE$8 = Symbol('@@webxr-polyfill/XRSpace'); + +class XRSpace { + constructor(specialType = null, inputSource = null) { + this[PRIVATE$8] = { + specialType, + inputSource, + }; + } + get _specialType() { + return this[PRIVATE$8].specialType; + } + get _inputSource() { + return this[PRIVATE$8].inputSource; + } +} + +const DEFAULT_EMULATION_HEIGHT = 1.6; +const PRIVATE$9 = Symbol('@@webxr-polyfill/XRReferenceSpace'); +const XRReferenceSpaceTypes = [ + 'viewer', + 'local', + 'local-floor', + 'bounded-floor', + 'unbounded' +]; +function isFloor(type) { + return type === 'bounded-floor' || type === 'local-floor'; +} +class XRReferenceSpace extends XRSpace { + constructor(device, type, transform) { + if (!XRReferenceSpaceTypes.includes(type)) { + throw new Error(`XRReferenceSpaceType must be one of ${XRReferenceSpaceTypes}`); + } + super((type === 'viewer') ? 'viewer' : null); + if (type === 'bounded-floor' && !transform) { + throw new Error(`XRReferenceSpace cannot use 'bounded-floor' type if the platform does not provide the floor level`); + } + if (isFloor(type) && !transform) { + transform = identity(new Float32Array(16)); + transform[13] = DEFAULT_EMULATION_HEIGHT; + } + if (!transform) { + transform = identity(new Float32Array(16)); + } + this[PRIVATE$9] = { + type, + transform, + device, + originOffset : identity(new Float32Array(16)), + }; + } + _transformBasePoseMatrix(out, pose) { + multiply(out, this[PRIVATE$9].transform, pose); + } + _transformBaseViewMatrix(out, view) { + invert(out, this[PRIVATE$9].transform); + multiply(out, view, out); + } + _originOffsetMatrix() { + return this[PRIVATE$9].originOffset; + } + _adjustForOriginOffset(transformMatrix) { + let inverseOriginOffsetMatrix = identity(new Float32Array(16)); + invert(inverseOriginOffsetMatrix, this[PRIVATE$9].originOffset); + multiply(transformMatrix, inverseOriginOffsetMatrix, transformMatrix); + } + getOffsetReferenceSpace(additionalOffset) { + let newSpace = new XRReferenceSpace( + this[PRIVATE$9].device, + this[PRIVATE$9].type, + this[PRIVATE$9].transform, + this[PRIVATE$9].bounds); + multiply(newSpace[PRIVATE$9].originOffset, this[PRIVATE$9].originOffset, additionalOffset.matrix); + return newSpace; + } +} + +const POLYFILLED_XR_COMPATIBLE = Symbol('@@webxr-polyfill/polyfilled-xr-compatible'); +const XR_COMPATIBLE = Symbol('@@webxr-polyfill/xr-compatible'); + +const PRIVATE$10 = Symbol('@@webxr-polyfill/XRWebGLLayer'); +const XRWebGLLayerInit = Object.freeze({ + antialias: true, + depth: false, + stencil: false, + alpha: true, + multiview: false, + ignoreDepthValues: false, + framebufferScaleFactor: 1.0, +}); +class XRWebGLLayer { + constructor(session, context, layerInit={}) { + const config = Object.assign({}, XRWebGLLayerInit, layerInit); + if (!(session instanceof XRSession$1)) { + throw new Error('session must be a XRSession'); + } + if (session.ended) { + throw new Error(`InvalidStateError`); + } + if (context[POLYFILLED_XR_COMPATIBLE]) { + if (context[XR_COMPATIBLE] !== true) { + throw new Error(`InvalidStateError`); + } + } + const framebuffer = context.getParameter(context.FRAMEBUFFER_BINDING); + this[PRIVATE$10] = { + context, + config, + framebuffer, + session, + }; + } + get context() { return this[PRIVATE$10].context; } + get antialias() { return this[PRIVATE$10].config.antialias; } + get ignoreDepthValues() { return true; } + get framebuffer() { return this[PRIVATE$10].framebuffer; } + get framebufferWidth() { return this[PRIVATE$10].context.drawingBufferWidth; } + get framebufferHeight() { return this[PRIVATE$10].context.drawingBufferHeight; } + get _session() { return this[PRIVATE$10].session; } + getViewport(view) { + return view._getViewport(this); + } +} + +const PRIVATE$11 = Symbol('@@webxr-polyfill/XRSession'); +class XRSession$1 extends EventTarget { + constructor(device, mode, id) { + super(); + let immersive = mode != 'inline'; + let outputContext = null; + this[PRIVATE$11] = { + device, + mode, + immersive, + outputContext, + ended: false, + suspended: false, + suspendedCallback: null, + id, + activeRenderState: null, + pendingRenderState: null, + }; + const frame = new XRFrame(device, this, this[PRIVATE$11].id); + this[PRIVATE$11].frame = frame; + this[PRIVATE$11].onPresentationEnd = sessionId => { + if (sessionId !== this[PRIVATE$11].id) { + this[PRIVATE$11].suspended = false; + this.dispatchEvent('focus', { session: this }); + const suspendedCallback = this[PRIVATE$11].suspendedCallback; + this[PRIVATE$11].suspendedCallback = null; + if (suspendedCallback) { + this.requestAnimationFrame(suspendedCallback); + } + return; + } + this[PRIVATE$11].ended = true; + device.removeEventListener('@webvr-polyfill/vr-present-end', this[PRIVATE$11].onPresentationEnd); + device.removeEventListener('@webvr-polyfill/vr-present-start', this[PRIVATE$11].onPresentationStart); + device.removeEventListener('@@webvr-polyfill/input-select-start', this[PRIVATE$11].onSelectStart); + device.removeEventListener('@@webvr-polyfill/input-select-end', this[PRIVATE$11].onSelectEnd); + this.dispatchEvent('end', { session: this }); + }; + device.addEventListener('@@webxr-polyfill/vr-present-end', this[PRIVATE$11].onPresentationEnd); + this[PRIVATE$11].onPresentationStart = sessionId => { + if (sessionId === this[PRIVATE$11].id) { + return; + } + this[PRIVATE$11].suspended = true; + this.dispatchEvent('blur', { session: this }); + }; + device.addEventListener('@@webxr-polyfill/vr-present-start', this[PRIVATE$11].onPresentationStart); + this[PRIVATE$11].onSelectStart = evt => { + if (evt.sessionId !== this[PRIVATE$11].id) { + return; + } + this.dispatchEvent('selectstart', { + frame: this[PRIVATE$11].frame, + inputSource: evt.inputSource + }); + }; + device.addEventListener('@@webxr-polyfill/input-select-start', this[PRIVATE$11].onSelectStart); + this[PRIVATE$11].onSelectEnd = evt => { + if (evt.sessionId !== this[PRIVATE$11].id) { + return; + } + this.dispatchEvent('selectend', { + frame: this[PRIVATE$11].frame, + inputSource: evt.inputSource + }); + this.dispatchEvent('select', { + frame: this[PRIVATE$11].frame, + inputSource: evt.inputSource + }); + }; + device.addEventListener('@@webxr-polyfill/input-select-end', this[PRIVATE$11].onSelectEnd); + this.onblur = undefined; + this.onfocus = undefined; + this.onresetpose = undefined; + this.onend = undefined; + this.onselect = undefined; + this.onselectstart = undefined; + this.onselectend = undefined; + } + get renderState() { return this[PRIVATE$11].activeRenderState; } + get immersive() { return this[PRIVATE$11].immersive; } + get outputContext() { return this[PRIVATE$11].outputContext; } + get depthNear() { return this[PRIVATE$11].device.depthNear; } + set depthNear(value) { this[PRIVATE$11].device.depthNear = value; } + get depthFar() { return this[PRIVATE$11].device.depthFar; } + set depthFar(value) { this[PRIVATE$11].device.depthFar = value; } + get environmentBlendMode() { + return this[PRIVATE$11].device.environmentBlendMode || 'opaque'; + } + get baseLayer() { return this[PRIVATE$11].baseLayer; } + set baseLayer(value) { + if (this[PRIVATE$11].ended) { + return; + } + this[PRIVATE$11].baseLayer = value; + this[PRIVATE$11].device.onBaseLayerSet(this[PRIVATE$11].id, value); + } + async requestReferenceSpace(type) { + if (this[PRIVATE$11].ended) { + return; + } + if (type === 'unbounded') { + throw new NotSupportedError(`The WebXR polyfill does not support the ${type} reference space`); + } + if (!XRReferenceSpaceTypes.includes(type)) { + throw new TypeError(`XRReferenceSpaceType must be one of ${XRReferenceSpaceTypes}`); + } + let transform = await this[PRIVATE$11].device.requestFrameOfReferenceTransform(type); + if (type === 'bounded-floor') { + if (!transform) { + throw new NotSupportedError(`${type} XRReferenceSpace not supported by this device.`); + } + let bounds = this[PRIVATE$11].device.requestStageBounds(); + if (!bounds) { + throw new NotSupportedError(`${type} XRReferenceSpace not supported by this device.`); + } + throw new NotSupportedError(`The WebXR polyfill does not support the ${type} reference space yet.`); + } + return new XRReferenceSpace(this[PRIVATE$11].device, type, transform); + } + requestAnimationFrame(callback) { + if (this[PRIVATE$11].ended) { + return; + } + if (this[PRIVATE$11].suspended && this[PRIVATE$11].suspendedCallback) { + return; + } + if (this[PRIVATE$11].suspended && !this[PRIVATE$11].suspendedCallback) { + this[PRIVATE$11].suspendedCallback = callback; + } + return this[PRIVATE$11].device.requestAnimationFrame(() => { + if (this[PRIVATE$11].pendingRenderState !== null) { + this[PRIVATE$11].activeRenderState = this[PRIVATE$11].pendingRenderState; + this[PRIVATE$11].pendingRenderState = null; + if (this[PRIVATE$11].activeRenderState.baseLayer) { + this[PRIVATE$11].device.onBaseLayerSet( + this[PRIVATE$11].id, + this[PRIVATE$11].activeRenderState.baseLayer); + } + if (this[PRIVATE$11].activeRenderState.inlineVerticalFieldOfView) { + this[PRIVATE$11].device.onInlineVerticalFieldOfViewSet( + this[PRIVATE$11].id, + this[PRIVATE$11].activeRenderState.inlineVerticalFieldOfView); + } + } + this[PRIVATE$11].device.onFrameStart(this[PRIVATE$11].id); + callback(now$1(), this[PRIVATE$11].frame); + this[PRIVATE$11].device.onFrameEnd(this[PRIVATE$11].id); + }); + } + cancelAnimationFrame(handle) { + if (this[PRIVATE$11].ended) { + return; + } + this[PRIVATE$11].device.cancelAnimationFrame(handle); + } + get inputSources() { + return this[PRIVATE$11].device.getInputSources(); + } + async end() { + if (this[PRIVATE$11].ended) { + return; + } + if (!this.immersive) { + this[PRIVATE$11].ended = true; + this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/vr-present-start', + this[PRIVATE$11].onPresentationStart); + this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/vr-present-end', + this[PRIVATE$11].onPresentationEnd); + this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/input-select-start', + this[PRIVATE$11].onSelectStart); + this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/input-select-end', + this[PRIVATE$11].onSelectEnd); + this.dispatchEvent('end', { session: this }); + } + return this[PRIVATE$11].device.endSession(this[PRIVATE$11].id); + } + updateRenderState(newState) { + if (this[PRIVATE$11].ended) { + const message = "Can't call updateRenderState on an XRSession " + + "that has already ended."; + throw new Error(message); + } + if (newState.baseLayer && (newState.baseLayer._session !== this)) { + const message = "Called updateRenderState with a base layer that was " + + "created by a different session."; + throw new Error(message); + } + const fovSet = (newState.inlineVerticalFieldOfView !== null) && + (newState.inlineVerticalFieldOfView !== undefined); + if (fovSet) { + if (this[PRIVATE$11].immersive) { + const message = "inlineVerticalFieldOfView must not be set for an " + + "XRRenderState passed to updateRenderState for an " + + "immersive session."; + throw new Error(message); + } else { + newState.inlineVerticalFieldOfView = Math.min( + 3.13, Math.max(0.01, newState.inlineVerticalFieldOfView)); + } + } + if (this[PRIVATE$11].pendingRenderState === null) { + this[PRIVATE$11].pendingRenderState = Object.assign( + {}, this[PRIVATE$11].activeRenderState, newState); + } + } +} + +const PRIVATE$12 = Symbol('@@webxr-polyfill/XRInputSource'); +class XRInputSource { + constructor(impl) { + this[PRIVATE$12] = { + impl, + gripSpace: new XRSpace("grip", this), + targetRaySpace: new XRSpace("target-ray", this) + }; + } + get handedness() { return this[PRIVATE$12].impl.handedness; } + get targetRayMode() { return this[PRIVATE$12].impl.targetRayMode; } + get gripSpace() { + let mode = this[PRIVATE$12].impl.targetRayMode; + if (mode === "gaze" || mode === "screen") { + return null; + } + return this[PRIVATE$12].gripSpace; + } + get targetRaySpace() { return this[PRIVATE$12].targetRaySpace; } + get profiles() { return this[PRIVATE$12].impl.profiles; } + get gamepad() { return this[PRIVATE$12].impl.gamepad; } +} + +const PRIVATE$13 = Symbol('@@webxr-polyfill/XRRenderState'); +const XRRenderStateInit = Object.freeze({ + depthNear: 0.1, + depthFar: 1000.0, + inlineVerticalFieldOfView: null, + baseLayer: null +}); +class XRRenderState { + constructor(stateInit = {}) { + const config = Object.assign({}, XRRenderStateInit, stateInit); + this[PRIVATE$13] = { config }; + } + get depthNear() { return this[PRIVATE$13].depthNear; } + get depthFar() { return this[PRIVATE$13].depthFar; } + get inlineVerticalFieldOfView() { return this[PRIVATE$13].inlineVerticalFieldOfView; } + get baseLayer() { return this[PRIVATE$13].baseLayer; } +} + +var API = { + XR: XR$1, + XRSession: XRSession$1, + XRFrame, + XRView, + XRViewport, + XRViewerPose, + XRWebGLLayer, + XRSpace, + XRReferenceSpace, + XRInputSource, + XRRenderState, + XRRigidTransform: XRRigidTransform$1, + XRPose: XRPose$1, +}; + +const polyfillMakeXRCompatible = Context => { + if (typeof Context.prototype.makeXRCompatible === 'function') { + return false; + } + Context.prototype.makeXRCompatible = function () { + this[XR_COMPATIBLE] = true; + return Promise.resolve(); + }; + return true; +}; +const polyfillGetContext = (Canvas) => { + const getContext = Canvas.prototype.getContext; + Canvas.prototype.getContext = function (contextType, glAttribs) { + const ctx = getContext.call(this, contextType, glAttribs); + if (ctx) { + ctx[POLYFILLED_XR_COMPATIBLE] = true; + if (glAttribs && ('xrCompatible' in glAttribs)) { + ctx[XR_COMPATIBLE] = glAttribs.xrCompatible; + } + } + return ctx; + }; +}; + +const isImageBitmapSupported = global => + !!(global.ImageBitmapRenderingContext && + global.createImageBitmap); + +const applyCanvasStylesForMinimalRendering = canvas => { + canvas.style.display = 'block'; + canvas.style.position = 'absolute'; + canvas.style.width = canvas.style.height = '1px'; + canvas.style.top = canvas.style.left = '0px'; +}; + +var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + + +function unwrapExports (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; +} + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var cardboardVrDisplay = createCommonjsModule(function (module, exports) { +(function (global, factory) { + module.exports = factory(); +}(commonjsGlobal, (function () { var classCallCheck = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +}; +var createClass = 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); + } + } + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; +}(); +var slicedToArray = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + return _arr; + } + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; +}(); +var MIN_TIMESTEP = 0.001; +var MAX_TIMESTEP = 1; +var dataUri = function dataUri(mimeType, svg) { + return 'data:' + mimeType + ',' + encodeURIComponent(svg); +}; +var lerp = function lerp(a, b, t) { + return a + (b - a) * t; +}; +var isIOS = function () { + var isIOS = /iPad|iPhone|iPod/.test(navigator.platform); + return function () { + return isIOS; + }; +}(); +var isWebViewAndroid = function () { + var isWebViewAndroid = navigator.userAgent.indexOf('Version') !== -1 && navigator.userAgent.indexOf('Android') !== -1 && navigator.userAgent.indexOf('Chrome') !== -1; + return function () { + return isWebViewAndroid; + }; +}(); +var isSafari = function () { + var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent); + return function () { + return isSafari; + }; +}(); +var isFirefoxAndroid = function () { + var isFirefoxAndroid = navigator.userAgent.indexOf('Firefox') !== -1 && navigator.userAgent.indexOf('Android') !== -1; + return function () { + return isFirefoxAndroid; + }; +}(); +var getChromeVersion = function () { + var match = navigator.userAgent.match(/.*Chrome\/([0-9]+)/); + var value = match ? parseInt(match[1], 10) : null; + return function () { + return value; + }; +}(); +var isChromeWithoutDeviceMotion = function () { + var value = false; + if (getChromeVersion() === 65) { + var match = navigator.userAgent.match(/.*Chrome\/([0-9\.]*)/); + if (match) { + var _match$1$split = match[1].split('.'), + _match$1$split2 = slicedToArray(_match$1$split, 4), + major = _match$1$split2[0], + minor = _match$1$split2[1], + branch = _match$1$split2[2], + build = _match$1$split2[3]; + value = parseInt(branch, 10) === 3325 && parseInt(build, 10) < 148; + } + } + return function () { + return value; + }; +}(); +var isR7 = function () { + var isR7 = navigator.userAgent.indexOf('R7 Build') !== -1; + return function () { + return isR7; + }; +}(); +var isLandscapeMode = function isLandscapeMode() { + var rtn = window.orientation == 90 || window.orientation == -90; + return isR7() ? !rtn : rtn; +}; +var isTimestampDeltaValid = function isTimestampDeltaValid(timestampDeltaS) { + if (isNaN(timestampDeltaS)) { + return false; + } + if (timestampDeltaS <= MIN_TIMESTEP) { + return false; + } + if (timestampDeltaS > MAX_TIMESTEP) { + return false; + } + return true; +}; +var getScreenWidth = function getScreenWidth() { + return Math.max(window.screen.width, window.screen.height) * window.devicePixelRatio; +}; +var getScreenHeight = function getScreenHeight() { + return Math.min(window.screen.width, window.screen.height) * window.devicePixelRatio; +}; +var requestFullscreen = function requestFullscreen(element) { + if (isWebViewAndroid()) { + return false; + } + if (element.requestFullscreen) { + element.requestFullscreen(); + } else if (element.webkitRequestFullscreen) { + element.webkitRequestFullscreen(); + } else if (element.mozRequestFullScreen) { + element.mozRequestFullScreen(); + } else if (element.msRequestFullscreen) { + element.msRequestFullscreen(); + } else { + return false; + } + return true; +}; +var exitFullscreen = function exitFullscreen() { + if (document.exitFullscreen) { + document.exitFullscreen(); + } else if (document.webkitExitFullscreen) { + document.webkitExitFullscreen(); + } else if (document.mozCancelFullScreen) { + document.mozCancelFullScreen(); + } else if (document.msExitFullscreen) { + document.msExitFullscreen(); + } else { + return false; + } + return true; +}; +var getFullscreenElement = function getFullscreenElement() { + return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement; +}; +var linkProgram = function linkProgram(gl, vertexSource, fragmentSource, attribLocationMap) { + var vertexShader = gl.createShader(gl.VERTEX_SHADER); + gl.shaderSource(vertexShader, vertexSource); + gl.compileShader(vertexShader); + var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER); + gl.shaderSource(fragmentShader, fragmentSource); + gl.compileShader(fragmentShader); + var program = gl.createProgram(); + gl.attachShader(program, vertexShader); + gl.attachShader(program, fragmentShader); + for (var attribName in attribLocationMap) { + gl.bindAttribLocation(program, attribLocationMap[attribName], attribName); + }gl.linkProgram(program); + gl.deleteShader(vertexShader); + gl.deleteShader(fragmentShader); + return program; +}; +var getProgramUniforms = function getProgramUniforms(gl, program) { + var uniforms = {}; + var uniformCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS); + var uniformName = ''; + for (var i = 0; i < uniformCount; i++) { + var uniformInfo = gl.getActiveUniform(program, i); + uniformName = uniformInfo.name.replace('[0]', ''); + uniforms[uniformName] = gl.getUniformLocation(program, uniformName); + } + return uniforms; +}; +var orthoMatrix = function orthoMatrix(out, left, right, bottom, top, near, far) { + var lr = 1 / (left - right), + bt = 1 / (bottom - top), + nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 2 * nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = (far + near) * nf; + out[15] = 1; + return out; +}; +var isMobile = function isMobile() { + var check = false; + (function (a) { + if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4))) check = true; + })(navigator.userAgent || navigator.vendor || window.opera); + return check; +}; +var extend = function extend(dest, src) { + for (var key in src) { + if (src.hasOwnProperty(key)) { + dest[key] = src[key]; + } + } + return dest; +}; +var safariCssSizeWorkaround = function safariCssSizeWorkaround(canvas) { + if (isIOS()) { + var width = canvas.style.width; + var height = canvas.style.height; + canvas.style.width = parseInt(width) + 1 + 'px'; + canvas.style.height = parseInt(height) + 'px'; + setTimeout(function () { + canvas.style.width = width; + canvas.style.height = height; + }, 100); + } + window.canvas = canvas; +}; +var frameDataFromPose = function () { + var piOver180 = Math.PI / 180.0; + var rad45 = Math.PI * 0.25; + function mat4_perspectiveFromFieldOfView(out, fov, near, far) { + var upTan = Math.tan(fov ? fov.upDegrees * piOver180 : rad45), + downTan = Math.tan(fov ? fov.downDegrees * piOver180 : rad45), + leftTan = Math.tan(fov ? fov.leftDegrees * piOver180 : rad45), + rightTan = Math.tan(fov ? fov.rightDegrees * piOver180 : rad45), + xScale = 2.0 / (leftTan + rightTan), + yScale = 2.0 / (upTan + downTan); + out[0] = xScale; + out[1] = 0.0; + out[2] = 0.0; + out[3] = 0.0; + out[4] = 0.0; + out[5] = yScale; + out[6] = 0.0; + out[7] = 0.0; + out[8] = -((leftTan - rightTan) * xScale * 0.5); + out[9] = (upTan - downTan) * yScale * 0.5; + out[10] = far / (near - far); + out[11] = -1.0; + out[12] = 0.0; + out[13] = 0.0; + out[14] = far * near / (near - far); + out[15] = 0.0; + return out; + } + function mat4_fromRotationTranslation(out, q, v) { + var x = q[0], + y = q[1], + z = q[2], + w = q[3], + x2 = x + x, + y2 = y + y, + z2 = z + z, + xx = x * x2, + xy = x * y2, + xz = x * z2, + yy = y * y2, + yz = y * z2, + zz = z * z2, + wx = w * x2, + wy = w * y2, + wz = w * z2; + out[0] = 1 - (yy + zz); + out[1] = xy + wz; + out[2] = xz - wy; + out[3] = 0; + out[4] = xy - wz; + out[5] = 1 - (xx + zz); + out[6] = yz + wx; + out[7] = 0; + out[8] = xz + wy; + out[9] = yz - wx; + out[10] = 1 - (xx + yy); + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; + } + function mat4_translate(out, a, v) { + var x = v[0], + y = v[1], + z = v[2], + a00, + a01, + a02, + a03, + a10, + a11, + a12, + a13, + a20, + a21, + a22, + a23; + if (a === out) { + out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; + out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; + out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; + out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; + } else { + a00 = a[0];a01 = a[1];a02 = a[2];a03 = a[3]; + a10 = a[4];a11 = a[5];a12 = a[6];a13 = a[7]; + a20 = a[8];a21 = a[9];a22 = a[10];a23 = a[11]; + out[0] = a00;out[1] = a01;out[2] = a02;out[3] = a03; + out[4] = a10;out[5] = a11;out[6] = a12;out[7] = a13; + out[8] = a20;out[9] = a21;out[10] = a22;out[11] = a23; + out[12] = a00 * x + a10 * y + a20 * z + a[12]; + out[13] = a01 * x + a11 * y + a21 * z + a[13]; + out[14] = a02 * x + a12 * y + a22 * z + a[14]; + out[15] = a03 * x + a13 * y + a23 * z + a[15]; + } + return out; + } + function mat4_invert(out, a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a03 = a[3], + a10 = a[4], + a11 = a[5], + a12 = a[6], + a13 = a[7], + a20 = a[8], + a21 = a[9], + a22 = a[10], + a23 = a[11], + a30 = a[12], + a31 = a[13], + a32 = a[14], + a33 = a[15], + b00 = a00 * a11 - a01 * a10, + b01 = a00 * a12 - a02 * a10, + b02 = a00 * a13 - a03 * a10, + b03 = a01 * a12 - a02 * a11, + b04 = a01 * a13 - a03 * a11, + b05 = a02 * a13 - a03 * a12, + b06 = a20 * a31 - a21 * a30, + b07 = a20 * a32 - a22 * a30, + b08 = a20 * a33 - a23 * a30, + b09 = a21 * a32 - a22 * a31, + b10 = a21 * a33 - a23 * a31, + b11 = a22 * a33 - a23 * a32, + det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + if (!det) { + return null; + } + det = 1.0 / det; + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + return out; + } + var defaultOrientation = new Float32Array([0, 0, 0, 1]); + var defaultPosition = new Float32Array([0, 0, 0]); + function updateEyeMatrices(projection, view, pose, fov, offset, vrDisplay) { + mat4_perspectiveFromFieldOfView(projection, fov || null, vrDisplay.depthNear, vrDisplay.depthFar); + var orientation = pose.orientation || defaultOrientation; + var position = pose.position || defaultPosition; + mat4_fromRotationTranslation(view, orientation, position); + if (offset) mat4_translate(view, view, offset); + mat4_invert(view, view); + } + return function (frameData, pose, vrDisplay) { + if (!frameData || !pose) return false; + frameData.pose = pose; + frameData.timestamp = pose.timestamp; + updateEyeMatrices(frameData.leftProjectionMatrix, frameData.leftViewMatrix, pose, vrDisplay._getFieldOfView("left"), vrDisplay._getEyeOffset("left"), vrDisplay); + updateEyeMatrices(frameData.rightProjectionMatrix, frameData.rightViewMatrix, pose, vrDisplay._getFieldOfView("right"), vrDisplay._getEyeOffset("right"), vrDisplay); + return true; + }; +}(); +var isInsideCrossOriginIFrame = function isInsideCrossOriginIFrame() { + var isFramed = window.self !== window.top; + var refOrigin = getOriginFromUrl(document.referrer); + var thisOrigin = getOriginFromUrl(window.location.href); + return isFramed && refOrigin !== thisOrigin; +}; +var getOriginFromUrl = function getOriginFromUrl(url) { + var domainIdx; + var protoSepIdx = url.indexOf("://"); + if (protoSepIdx !== -1) { + domainIdx = protoSepIdx + 3; + } else { + domainIdx = 0; + } + var domainEndIdx = url.indexOf('/', domainIdx); + if (domainEndIdx === -1) { + domainEndIdx = url.length; + } + return url.substring(0, domainEndIdx); +}; +var getQuaternionAngle = function getQuaternionAngle(quat) { + if (quat.w > 1) { + console.warn('getQuaternionAngle: w > 1'); + return 0; + } + var angle = 2 * Math.acos(quat.w); + return angle; +}; +var warnOnce = function () { + var observedWarnings = {}; + return function (key, message) { + if (observedWarnings[key] === undefined) { + console.warn('webvr-polyfill: ' + message); + observedWarnings[key] = true; + } + }; +}(); +var deprecateWarning = function deprecateWarning(deprecated, suggested) { + var alternative = suggested ? 'Please use ' + suggested + ' instead.' : ''; + warnOnce(deprecated, deprecated + ' has been deprecated. ' + 'This may not work on native WebVR displays. ' + alternative); +}; +function WGLUPreserveGLState(gl, bindings, callback) { + if (!bindings) { + callback(gl); + return; + } + var boundValues = []; + var activeTexture = null; + for (var i = 0; i < bindings.length; ++i) { + var binding = bindings[i]; + switch (binding) { + case gl.TEXTURE_BINDING_2D: + case gl.TEXTURE_BINDING_CUBE_MAP: + var textureUnit = bindings[++i]; + if (textureUnit < gl.TEXTURE0 || textureUnit > gl.TEXTURE31) { + console.error("TEXTURE_BINDING_2D or TEXTURE_BINDING_CUBE_MAP must be followed by a valid texture unit"); + boundValues.push(null, null); + break; + } + if (!activeTexture) { + activeTexture = gl.getParameter(gl.ACTIVE_TEXTURE); + } + gl.activeTexture(textureUnit); + boundValues.push(gl.getParameter(binding), null); + break; + case gl.ACTIVE_TEXTURE: + activeTexture = gl.getParameter(gl.ACTIVE_TEXTURE); + boundValues.push(null); + break; + default: + boundValues.push(gl.getParameter(binding)); + break; + } + } + callback(gl); + for (var i = 0; i < bindings.length; ++i) { + var binding = bindings[i]; + var boundValue = boundValues[i]; + switch (binding) { + case gl.ACTIVE_TEXTURE: + break; + case gl.ARRAY_BUFFER_BINDING: + gl.bindBuffer(gl.ARRAY_BUFFER, boundValue); + break; + case gl.COLOR_CLEAR_VALUE: + gl.clearColor(boundValue[0], boundValue[1], boundValue[2], boundValue[3]); + break; + case gl.COLOR_WRITEMASK: + gl.colorMask(boundValue[0], boundValue[1], boundValue[2], boundValue[3]); + break; + case gl.CURRENT_PROGRAM: + gl.useProgram(boundValue); + break; + case gl.ELEMENT_ARRAY_BUFFER_BINDING: + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, boundValue); + break; + case gl.FRAMEBUFFER_BINDING: + gl.bindFramebuffer(gl.FRAMEBUFFER, boundValue); + break; + case gl.RENDERBUFFER_BINDING: + gl.bindRenderbuffer(gl.RENDERBUFFER, boundValue); + break; + case gl.TEXTURE_BINDING_2D: + var textureUnit = bindings[++i]; + if (textureUnit < gl.TEXTURE0 || textureUnit > gl.TEXTURE31) + break; + gl.activeTexture(textureUnit); + gl.bindTexture(gl.TEXTURE_2D, boundValue); + break; + case gl.TEXTURE_BINDING_CUBE_MAP: + var textureUnit = bindings[++i]; + if (textureUnit < gl.TEXTURE0 || textureUnit > gl.TEXTURE31) + break; + gl.activeTexture(textureUnit); + gl.bindTexture(gl.TEXTURE_CUBE_MAP, boundValue); + break; + case gl.VIEWPORT: + gl.viewport(boundValue[0], boundValue[1], boundValue[2], boundValue[3]); + break; + case gl.BLEND: + case gl.CULL_FACE: + case gl.DEPTH_TEST: + case gl.SCISSOR_TEST: + case gl.STENCIL_TEST: + if (boundValue) { + gl.enable(binding); + } else { + gl.disable(binding); + } + break; + default: + console.log("No GL restore behavior for 0x" + binding.toString(16)); + break; + } + if (activeTexture) { + gl.activeTexture(activeTexture); + } + } +} +var glPreserveState = WGLUPreserveGLState; +var distortionVS = ['attribute vec2 position;', 'attribute vec3 texCoord;', 'varying vec2 vTexCoord;', 'uniform vec4 viewportOffsetScale[2];', 'void main() {', ' vec4 viewport = viewportOffsetScale[int(texCoord.z)];', ' vTexCoord = (texCoord.xy * viewport.zw) + viewport.xy;', ' gl_Position = vec4( position, 1.0, 1.0 );', '}'].join('\n'); +var distortionFS = ['precision mediump float;', 'uniform sampler2D diffuse;', 'varying vec2 vTexCoord;', 'void main() {', ' gl_FragColor = texture2D(diffuse, vTexCoord);', '}'].join('\n'); +function CardboardDistorter(gl, cardboardUI, bufferScale, dirtySubmitFrameBindings) { + this.gl = gl; + this.cardboardUI = cardboardUI; + this.bufferScale = bufferScale; + this.dirtySubmitFrameBindings = dirtySubmitFrameBindings; + this.ctxAttribs = gl.getContextAttributes(); + this.meshWidth = 20; + this.meshHeight = 20; + this.bufferWidth = gl.drawingBufferWidth; + this.bufferHeight = gl.drawingBufferHeight; + this.realBindFramebuffer = gl.bindFramebuffer; + this.realEnable = gl.enable; + this.realDisable = gl.disable; + this.realColorMask = gl.colorMask; + this.realClearColor = gl.clearColor; + this.realViewport = gl.viewport; + if (!isIOS()) { + this.realCanvasWidth = Object.getOwnPropertyDescriptor(gl.canvas.__proto__, 'width'); + this.realCanvasHeight = Object.getOwnPropertyDescriptor(gl.canvas.__proto__, 'height'); + } + this.isPatched = false; + this.lastBoundFramebuffer = null; + this.cullFace = false; + this.depthTest = false; + this.blend = false; + this.scissorTest = false; + this.stencilTest = false; + this.viewport = [0, 0, 0, 0]; + this.colorMask = [true, true, true, true]; + this.clearColor = [0, 0, 0, 0]; + this.attribs = { + position: 0, + texCoord: 1 + }; + this.program = linkProgram(gl, distortionVS, distortionFS, this.attribs); + this.uniforms = getProgramUniforms(gl, this.program); + this.viewportOffsetScale = new Float32Array(8); + this.setTextureBounds(); + this.vertexBuffer = gl.createBuffer(); + this.indexBuffer = gl.createBuffer(); + this.indexCount = 0; + this.renderTarget = gl.createTexture(); + this.framebuffer = gl.createFramebuffer(); + this.depthStencilBuffer = null; + this.depthBuffer = null; + this.stencilBuffer = null; + if (this.ctxAttribs.depth && this.ctxAttribs.stencil) { + this.depthStencilBuffer = gl.createRenderbuffer(); + } else if (this.ctxAttribs.depth) { + this.depthBuffer = gl.createRenderbuffer(); + } else if (this.ctxAttribs.stencil) { + this.stencilBuffer = gl.createRenderbuffer(); + } + this.patch(); + this.onResize(); +} +CardboardDistorter.prototype.destroy = function () { + var gl = this.gl; + this.unpatch(); + gl.deleteProgram(this.program); + gl.deleteBuffer(this.vertexBuffer); + gl.deleteBuffer(this.indexBuffer); + gl.deleteTexture(this.renderTarget); + gl.deleteFramebuffer(this.framebuffer); + if (this.depthStencilBuffer) { + gl.deleteRenderbuffer(this.depthStencilBuffer); + } + if (this.depthBuffer) { + gl.deleteRenderbuffer(this.depthBuffer); + } + if (this.stencilBuffer) { + gl.deleteRenderbuffer(this.stencilBuffer); + } + if (this.cardboardUI) { + this.cardboardUI.destroy(); + } +}; +CardboardDistorter.prototype.onResize = function () { + var gl = this.gl; + var self = this; + var glState = [gl.RENDERBUFFER_BINDING, gl.TEXTURE_BINDING_2D, gl.TEXTURE0]; + glPreserveState(gl, glState, function (gl) { + self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, null); + if (self.scissorTest) { + self.realDisable.call(gl, gl.SCISSOR_TEST); + } + self.realColorMask.call(gl, true, true, true, true); + self.realViewport.call(gl, 0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight); + self.realClearColor.call(gl, 0, 0, 0, 1); + gl.clear(gl.COLOR_BUFFER_BIT); + self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, self.framebuffer); + gl.bindTexture(gl.TEXTURE_2D, self.renderTarget); + gl.texImage2D(gl.TEXTURE_2D, 0, self.ctxAttribs.alpha ? gl.RGBA : gl.RGB, self.bufferWidth, self.bufferHeight, 0, self.ctxAttribs.alpha ? gl.RGBA : gl.RGB, gl.UNSIGNED_BYTE, null); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, self.renderTarget, 0); + if (self.ctxAttribs.depth && self.ctxAttribs.stencil) { + gl.bindRenderbuffer(gl.RENDERBUFFER, self.depthStencilBuffer); + gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, self.bufferWidth, self.bufferHeight); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, self.depthStencilBuffer); + } else if (self.ctxAttribs.depth) { + gl.bindRenderbuffer(gl.RENDERBUFFER, self.depthBuffer); + gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, self.bufferWidth, self.bufferHeight); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, self.depthBuffer); + } else if (self.ctxAttribs.stencil) { + gl.bindRenderbuffer(gl.RENDERBUFFER, self.stencilBuffer); + gl.renderbufferStorage(gl.RENDERBUFFER, gl.STENCIL_INDEX8, self.bufferWidth, self.bufferHeight); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, self.stencilBuffer); + } + if (!gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE) { + console.error('Framebuffer incomplete!'); + } + self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, self.lastBoundFramebuffer); + if (self.scissorTest) { + self.realEnable.call(gl, gl.SCISSOR_TEST); + } + self.realColorMask.apply(gl, self.colorMask); + self.realViewport.apply(gl, self.viewport); + self.realClearColor.apply(gl, self.clearColor); + }); + if (this.cardboardUI) { + this.cardboardUI.onResize(); + } +}; +CardboardDistorter.prototype.patch = function () { + if (this.isPatched) { + return; + } + var self = this; + var canvas = this.gl.canvas; + var gl = this.gl; + if (!isIOS()) { + canvas.width = getScreenWidth() * this.bufferScale; + canvas.height = getScreenHeight() * this.bufferScale; + Object.defineProperty(canvas, 'width', { + configurable: true, + enumerable: true, + get: function get() { + return self.bufferWidth; + }, + set: function set(value) { + self.bufferWidth = value; + self.realCanvasWidth.set.call(canvas, value); + self.onResize(); + } + }); + Object.defineProperty(canvas, 'height', { + configurable: true, + enumerable: true, + get: function get() { + return self.bufferHeight; + }, + set: function set(value) { + self.bufferHeight = value; + self.realCanvasHeight.set.call(canvas, value); + self.onResize(); + } + }); + } + this.lastBoundFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING); + if (this.lastBoundFramebuffer == null) { + this.lastBoundFramebuffer = this.framebuffer; + this.gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer); + } + this.gl.bindFramebuffer = function (target, framebuffer) { + self.lastBoundFramebuffer = framebuffer ? framebuffer : self.framebuffer; + self.realBindFramebuffer.call(gl, target, self.lastBoundFramebuffer); + }; + this.cullFace = gl.getParameter(gl.CULL_FACE); + this.depthTest = gl.getParameter(gl.DEPTH_TEST); + this.blend = gl.getParameter(gl.BLEND); + this.scissorTest = gl.getParameter(gl.SCISSOR_TEST); + this.stencilTest = gl.getParameter(gl.STENCIL_TEST); + gl.enable = function (pname) { + switch (pname) { + case gl.CULL_FACE: + self.cullFace = true;break; + case gl.DEPTH_TEST: + self.depthTest = true;break; + case gl.BLEND: + self.blend = true;break; + case gl.SCISSOR_TEST: + self.scissorTest = true;break; + case gl.STENCIL_TEST: + self.stencilTest = true;break; + } + self.realEnable.call(gl, pname); + }; + gl.disable = function (pname) { + switch (pname) { + case gl.CULL_FACE: + self.cullFace = false;break; + case gl.DEPTH_TEST: + self.depthTest = false;break; + case gl.BLEND: + self.blend = false;break; + case gl.SCISSOR_TEST: + self.scissorTest = false;break; + case gl.STENCIL_TEST: + self.stencilTest = false;break; + } + self.realDisable.call(gl, pname); + }; + this.colorMask = gl.getParameter(gl.COLOR_WRITEMASK); + gl.colorMask = function (r, g, b, a) { + self.colorMask[0] = r; + self.colorMask[1] = g; + self.colorMask[2] = b; + self.colorMask[3] = a; + self.realColorMask.call(gl, r, g, b, a); + }; + this.clearColor = gl.getParameter(gl.COLOR_CLEAR_VALUE); + gl.clearColor = function (r, g, b, a) { + self.clearColor[0] = r; + self.clearColor[1] = g; + self.clearColor[2] = b; + self.clearColor[3] = a; + self.realClearColor.call(gl, r, g, b, a); + }; + this.viewport = gl.getParameter(gl.VIEWPORT); + gl.viewport = function (x, y, w, h) { + self.viewport[0] = x; + self.viewport[1] = y; + self.viewport[2] = w; + self.viewport[3] = h; + self.realViewport.call(gl, x, y, w, h); + }; + this.isPatched = true; + safariCssSizeWorkaround(canvas); +}; +CardboardDistorter.prototype.unpatch = function () { + if (!this.isPatched) { + return; + } + var gl = this.gl; + var canvas = this.gl.canvas; + if (!isIOS()) { + Object.defineProperty(canvas, 'width', this.realCanvasWidth); + Object.defineProperty(canvas, 'height', this.realCanvasHeight); + } + canvas.width = this.bufferWidth; + canvas.height = this.bufferHeight; + gl.bindFramebuffer = this.realBindFramebuffer; + gl.enable = this.realEnable; + gl.disable = this.realDisable; + gl.colorMask = this.realColorMask; + gl.clearColor = this.realClearColor; + gl.viewport = this.realViewport; + if (this.lastBoundFramebuffer == this.framebuffer) { + gl.bindFramebuffer(gl.FRAMEBUFFER, null); + } + this.isPatched = false; + setTimeout(function () { + safariCssSizeWorkaround(canvas); + }, 1); +}; +CardboardDistorter.prototype.setTextureBounds = function (leftBounds, rightBounds) { + if (!leftBounds) { + leftBounds = [0, 0, 0.5, 1]; + } + if (!rightBounds) { + rightBounds = [0.5, 0, 0.5, 1]; + } + this.viewportOffsetScale[0] = leftBounds[0]; + this.viewportOffsetScale[1] = leftBounds[1]; + this.viewportOffsetScale[2] = leftBounds[2]; + this.viewportOffsetScale[3] = leftBounds[3]; + this.viewportOffsetScale[4] = rightBounds[0]; + this.viewportOffsetScale[5] = rightBounds[1]; + this.viewportOffsetScale[6] = rightBounds[2]; + this.viewportOffsetScale[7] = rightBounds[3]; +}; +CardboardDistorter.prototype.submitFrame = function () { + var gl = this.gl; + var self = this; + var glState = []; + if (!this.dirtySubmitFrameBindings) { + glState.push(gl.CURRENT_PROGRAM, gl.ARRAY_BUFFER_BINDING, gl.ELEMENT_ARRAY_BUFFER_BINDING, gl.TEXTURE_BINDING_2D, gl.TEXTURE0); + } + glPreserveState(gl, glState, function (gl) { + self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, null); + if (self.cullFace) { + self.realDisable.call(gl, gl.CULL_FACE); + } + if (self.depthTest) { + self.realDisable.call(gl, gl.DEPTH_TEST); + } + if (self.blend) { + self.realDisable.call(gl, gl.BLEND); + } + if (self.scissorTest) { + self.realDisable.call(gl, gl.SCISSOR_TEST); + } + if (self.stencilTest) { + self.realDisable.call(gl, gl.STENCIL_TEST); + } + self.realColorMask.call(gl, true, true, true, true); + self.realViewport.call(gl, 0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight); + if (self.ctxAttribs.alpha || isIOS()) { + self.realClearColor.call(gl, 0, 0, 0, 1); + gl.clear(gl.COLOR_BUFFER_BIT); + } + gl.useProgram(self.program); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, self.indexBuffer); + gl.bindBuffer(gl.ARRAY_BUFFER, self.vertexBuffer); + gl.enableVertexAttribArray(self.attribs.position); + gl.enableVertexAttribArray(self.attribs.texCoord); + gl.vertexAttribPointer(self.attribs.position, 2, gl.FLOAT, false, 20, 0); + gl.vertexAttribPointer(self.attribs.texCoord, 3, gl.FLOAT, false, 20, 8); + gl.activeTexture(gl.TEXTURE0); + gl.uniform1i(self.uniforms.diffuse, 0); + gl.bindTexture(gl.TEXTURE_2D, self.renderTarget); + gl.uniform4fv(self.uniforms.viewportOffsetScale, self.viewportOffsetScale); + gl.drawElements(gl.TRIANGLES, self.indexCount, gl.UNSIGNED_SHORT, 0); + if (self.cardboardUI) { + self.cardboardUI.renderNoState(); + } + self.realBindFramebuffer.call(self.gl, gl.FRAMEBUFFER, self.framebuffer); + if (!self.ctxAttribs.preserveDrawingBuffer) { + self.realClearColor.call(gl, 0, 0, 0, 0); + gl.clear(gl.COLOR_BUFFER_BIT); + } + if (!self.dirtySubmitFrameBindings) { + self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, self.lastBoundFramebuffer); + } + if (self.cullFace) { + self.realEnable.call(gl, gl.CULL_FACE); + } + if (self.depthTest) { + self.realEnable.call(gl, gl.DEPTH_TEST); + } + if (self.blend) { + self.realEnable.call(gl, gl.BLEND); + } + if (self.scissorTest) { + self.realEnable.call(gl, gl.SCISSOR_TEST); + } + if (self.stencilTest) { + self.realEnable.call(gl, gl.STENCIL_TEST); + } + self.realColorMask.apply(gl, self.colorMask); + self.realViewport.apply(gl, self.viewport); + if (self.ctxAttribs.alpha || !self.ctxAttribs.preserveDrawingBuffer) { + self.realClearColor.apply(gl, self.clearColor); + } + }); + if (isIOS()) { + var canvas = gl.canvas; + if (canvas.width != self.bufferWidth || canvas.height != self.bufferHeight) { + self.bufferWidth = canvas.width; + self.bufferHeight = canvas.height; + self.onResize(); + } + } +}; +CardboardDistorter.prototype.updateDeviceInfo = function (deviceInfo) { + var gl = this.gl; + var self = this; + var glState = [gl.ARRAY_BUFFER_BINDING, gl.ELEMENT_ARRAY_BUFFER_BINDING]; + glPreserveState(gl, glState, function (gl) { + var vertices = self.computeMeshVertices_(self.meshWidth, self.meshHeight, deviceInfo); + gl.bindBuffer(gl.ARRAY_BUFFER, self.vertexBuffer); + gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW); + if (!self.indexCount) { + var indices = self.computeMeshIndices_(self.meshWidth, self.meshHeight); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, self.indexBuffer); + gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW); + self.indexCount = indices.length; + } + }); +}; +CardboardDistorter.prototype.computeMeshVertices_ = function (width, height, deviceInfo) { + var vertices = new Float32Array(2 * width * height * 5); + var lensFrustum = deviceInfo.getLeftEyeVisibleTanAngles(); + var noLensFrustum = deviceInfo.getLeftEyeNoLensTanAngles(); + var viewport = deviceInfo.getLeftEyeVisibleScreenRect(noLensFrustum); + var vidx = 0; + for (var e = 0; e < 2; e++) { + for (var j = 0; j < height; j++) { + for (var i = 0; i < width; i++, vidx++) { + var u = i / (width - 1); + var v = j / (height - 1); + var s = u; + var t = v; + var x = lerp(lensFrustum[0], lensFrustum[2], u); + var y = lerp(lensFrustum[3], lensFrustum[1], v); + var d = Math.sqrt(x * x + y * y); + var r = deviceInfo.distortion.distortInverse(d); + var p = x * r / d; + var q = y * r / d; + u = (p - noLensFrustum[0]) / (noLensFrustum[2] - noLensFrustum[0]); + v = (q - noLensFrustum[3]) / (noLensFrustum[1] - noLensFrustum[3]); + u = (viewport.x + u * viewport.width - 0.5) * 2.0; + v = (viewport.y + v * viewport.height - 0.5) * 2.0; + vertices[vidx * 5 + 0] = u; + vertices[vidx * 5 + 1] = v; + vertices[vidx * 5 + 2] = s; + vertices[vidx * 5 + 3] = t; + vertices[vidx * 5 + 4] = e; + } + } + var w = lensFrustum[2] - lensFrustum[0]; + lensFrustum[0] = -(w + lensFrustum[0]); + lensFrustum[2] = w - lensFrustum[2]; + w = noLensFrustum[2] - noLensFrustum[0]; + noLensFrustum[0] = -(w + noLensFrustum[0]); + noLensFrustum[2] = w - noLensFrustum[2]; + viewport.x = 1 - (viewport.x + viewport.width); + } + return vertices; +}; +CardboardDistorter.prototype.computeMeshIndices_ = function (width, height) { + var indices = new Uint16Array(2 * (width - 1) * (height - 1) * 6); + var halfwidth = width / 2; + var halfheight = height / 2; + var vidx = 0; + var iidx = 0; + for (var e = 0; e < 2; e++) { + for (var j = 0; j < height; j++) { + for (var i = 0; i < width; i++, vidx++) { + if (i == 0 || j == 0) continue; + if (i <= halfwidth == j <= halfheight) { + indices[iidx++] = vidx; + indices[iidx++] = vidx - width - 1; + indices[iidx++] = vidx - width; + indices[iidx++] = vidx - width - 1; + indices[iidx++] = vidx; + indices[iidx++] = vidx - 1; + } else { + indices[iidx++] = vidx - 1; + indices[iidx++] = vidx - width; + indices[iidx++] = vidx; + indices[iidx++] = vidx - width; + indices[iidx++] = vidx - 1; + indices[iidx++] = vidx - width - 1; + } + } + } + } + return indices; +}; +CardboardDistorter.prototype.getOwnPropertyDescriptor_ = function (proto, attrName) { + var descriptor = Object.getOwnPropertyDescriptor(proto, attrName); + if (descriptor.get === undefined || descriptor.set === undefined) { + descriptor.configurable = true; + descriptor.enumerable = true; + descriptor.get = function () { + return this.getAttribute(attrName); + }; + descriptor.set = function (val) { + this.setAttribute(attrName, val); + }; + } + return descriptor; +}; +var uiVS = ['attribute vec2 position;', 'uniform mat4 projectionMat;', 'void main() {', ' gl_Position = projectionMat * vec4( position, -1.0, 1.0 );', '}'].join('\n'); +var uiFS = ['precision mediump float;', 'uniform vec4 color;', 'void main() {', ' gl_FragColor = color;', '}'].join('\n'); +var DEG2RAD = Math.PI / 180.0; +var kAnglePerGearSection = 60; +var kOuterRimEndAngle = 12; +var kInnerRimBeginAngle = 20; +var kOuterRadius = 1; +var kMiddleRadius = 0.75; +var kInnerRadius = 0.3125; +var kCenterLineThicknessDp = 4; +var kButtonWidthDp = 28; +var kTouchSlopFactor = 1.5; +function CardboardUI(gl) { + this.gl = gl; + this.attribs = { + position: 0 + }; + this.program = linkProgram(gl, uiVS, uiFS, this.attribs); + this.uniforms = getProgramUniforms(gl, this.program); + this.vertexBuffer = gl.createBuffer(); + this.gearOffset = 0; + this.gearVertexCount = 0; + this.arrowOffset = 0; + this.arrowVertexCount = 0; + this.projMat = new Float32Array(16); + this.listener = null; + this.onResize(); +} +CardboardUI.prototype.destroy = function () { + var gl = this.gl; + if (this.listener) { + gl.canvas.removeEventListener('click', this.listener, false); + } + gl.deleteProgram(this.program); + gl.deleteBuffer(this.vertexBuffer); +}; +CardboardUI.prototype.listen = function (optionsCallback, backCallback) { + var canvas = this.gl.canvas; + this.listener = function (event) { + var midline = canvas.clientWidth / 2; + var buttonSize = kButtonWidthDp * kTouchSlopFactor; + if (event.clientX > midline - buttonSize && event.clientX < midline + buttonSize && event.clientY > canvas.clientHeight - buttonSize) { + optionsCallback(event); + } + else if (event.clientX < buttonSize && event.clientY < buttonSize) { + backCallback(event); + } + }; + canvas.addEventListener('click', this.listener, false); +}; +CardboardUI.prototype.onResize = function () { + var gl = this.gl; + var self = this; + var glState = [gl.ARRAY_BUFFER_BINDING]; + glPreserveState(gl, glState, function (gl) { + var vertices = []; + var midline = gl.drawingBufferWidth / 2; + var physicalPixels = Math.max(screen.width, screen.height) * window.devicePixelRatio; + var scalingRatio = gl.drawingBufferWidth / physicalPixels; + var dps = scalingRatio * window.devicePixelRatio; + var lineWidth = kCenterLineThicknessDp * dps / 2; + var buttonSize = kButtonWidthDp * kTouchSlopFactor * dps; + var buttonScale = kButtonWidthDp * dps / 2; + var buttonBorder = (kButtonWidthDp * kTouchSlopFactor - kButtonWidthDp) * dps; + vertices.push(midline - lineWidth, buttonSize); + vertices.push(midline - lineWidth, gl.drawingBufferHeight); + vertices.push(midline + lineWidth, buttonSize); + vertices.push(midline + lineWidth, gl.drawingBufferHeight); + self.gearOffset = vertices.length / 2; + function addGearSegment(theta, r) { + var angle = (90 - theta) * DEG2RAD; + var x = Math.cos(angle); + var y = Math.sin(angle); + vertices.push(kInnerRadius * x * buttonScale + midline, kInnerRadius * y * buttonScale + buttonScale); + vertices.push(r * x * buttonScale + midline, r * y * buttonScale + buttonScale); + } + for (var i = 0; i <= 6; i++) { + var segmentTheta = i * kAnglePerGearSection; + addGearSegment(segmentTheta, kOuterRadius); + addGearSegment(segmentTheta + kOuterRimEndAngle, kOuterRadius); + addGearSegment(segmentTheta + kInnerRimBeginAngle, kMiddleRadius); + addGearSegment(segmentTheta + (kAnglePerGearSection - kInnerRimBeginAngle), kMiddleRadius); + addGearSegment(segmentTheta + (kAnglePerGearSection - kOuterRimEndAngle), kOuterRadius); + } + self.gearVertexCount = vertices.length / 2 - self.gearOffset; + self.arrowOffset = vertices.length / 2; + function addArrowVertex(x, y) { + vertices.push(buttonBorder + x, gl.drawingBufferHeight - buttonBorder - y); + } + var angledLineWidth = lineWidth / Math.sin(45 * DEG2RAD); + addArrowVertex(0, buttonScale); + addArrowVertex(buttonScale, 0); + addArrowVertex(buttonScale + angledLineWidth, angledLineWidth); + addArrowVertex(angledLineWidth, buttonScale + angledLineWidth); + addArrowVertex(angledLineWidth, buttonScale - angledLineWidth); + addArrowVertex(0, buttonScale); + addArrowVertex(buttonScale, buttonScale * 2); + addArrowVertex(buttonScale + angledLineWidth, buttonScale * 2 - angledLineWidth); + addArrowVertex(angledLineWidth, buttonScale - angledLineWidth); + addArrowVertex(0, buttonScale); + addArrowVertex(angledLineWidth, buttonScale - lineWidth); + addArrowVertex(kButtonWidthDp * dps, buttonScale - lineWidth); + addArrowVertex(angledLineWidth, buttonScale + lineWidth); + addArrowVertex(kButtonWidthDp * dps, buttonScale + lineWidth); + self.arrowVertexCount = vertices.length / 2 - self.arrowOffset; + gl.bindBuffer(gl.ARRAY_BUFFER, self.vertexBuffer); + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW); + }); +}; +CardboardUI.prototype.render = function () { + var gl = this.gl; + var self = this; + var glState = [gl.CULL_FACE, gl.DEPTH_TEST, gl.BLEND, gl.SCISSOR_TEST, gl.STENCIL_TEST, gl.COLOR_WRITEMASK, gl.VIEWPORT, gl.CURRENT_PROGRAM, gl.ARRAY_BUFFER_BINDING]; + glPreserveState(gl, glState, function (gl) { + gl.disable(gl.CULL_FACE); + gl.disable(gl.DEPTH_TEST); + gl.disable(gl.BLEND); + gl.disable(gl.SCISSOR_TEST); + gl.disable(gl.STENCIL_TEST); + gl.colorMask(true, true, true, true); + gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight); + self.renderNoState(); + }); +}; +CardboardUI.prototype.renderNoState = function () { + var gl = this.gl; + gl.useProgram(this.program); + gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer); + gl.enableVertexAttribArray(this.attribs.position); + gl.vertexAttribPointer(this.attribs.position, 2, gl.FLOAT, false, 8, 0); + gl.uniform4f(this.uniforms.color, 1.0, 1.0, 1.0, 1.0); + orthoMatrix(this.projMat, 0, gl.drawingBufferWidth, 0, gl.drawingBufferHeight, 0.1, 1024.0); + gl.uniformMatrix4fv(this.uniforms.projectionMat, false, this.projMat); + gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4); + gl.drawArrays(gl.TRIANGLE_STRIP, this.gearOffset, this.gearVertexCount); + gl.drawArrays(gl.TRIANGLE_STRIP, this.arrowOffset, this.arrowVertexCount); +}; +function Distortion(coefficients) { + this.coefficients = coefficients; +} +Distortion.prototype.distortInverse = function (radius) { + var r0 = 0; + var r1 = 1; + var dr0 = radius - this.distort(r0); + while (Math.abs(r1 - r0) > 0.0001 ) { + var dr1 = radius - this.distort(r1); + var r2 = r1 - dr1 * ((r1 - r0) / (dr1 - dr0)); + r0 = r1; + r1 = r2; + dr0 = dr1; + } + return r1; +}; +Distortion.prototype.distort = function (radius) { + var r2 = radius * radius; + var ret = 0; + for (var i = 0; i < this.coefficients.length; i++) { + ret = r2 * (ret + this.coefficients[i]); + } + return (ret + 1) * radius; +}; +var degToRad = Math.PI / 180; +var radToDeg = 180 / Math.PI; +var Vector3 = function Vector3(x, y, z) { + this.x = x || 0; + this.y = y || 0; + this.z = z || 0; +}; +Vector3.prototype = { + constructor: Vector3, + set: function set(x, y, z) { + this.x = x; + this.y = y; + this.z = z; + return this; + }, + copy: function copy(v) { + this.x = v.x; + this.y = v.y; + this.z = v.z; + return this; + }, + length: function length() { + return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z); + }, + normalize: function normalize() { + var scalar = this.length(); + if (scalar !== 0) { + var invScalar = 1 / scalar; + this.multiplyScalar(invScalar); + } else { + this.x = 0; + this.y = 0; + this.z = 0; + } + return this; + }, + multiplyScalar: function multiplyScalar(scalar) { + this.x *= scalar; + this.y *= scalar; + this.z *= scalar; + }, + applyQuaternion: function applyQuaternion(q) { + var x = this.x; + var y = this.y; + var z = this.z; + var qx = q.x; + var qy = q.y; + var qz = q.z; + var qw = q.w; + var ix = qw * x + qy * z - qz * y; + var iy = qw * y + qz * x - qx * z; + var iz = qw * z + qx * y - qy * x; + var iw = -qx * x - qy * y - qz * z; + this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy; + this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz; + this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx; + return this; + }, + dot: function dot(v) { + return this.x * v.x + this.y * v.y + this.z * v.z; + }, + crossVectors: function crossVectors(a, b) { + var ax = a.x, + ay = a.y, + az = a.z; + var bx = b.x, + by = b.y, + bz = b.z; + this.x = ay * bz - az * by; + this.y = az * bx - ax * bz; + this.z = ax * by - ay * bx; + return this; + } +}; +var Quaternion = function Quaternion(x, y, z, w) { + this.x = x || 0; + this.y = y || 0; + this.z = z || 0; + this.w = w !== undefined ? w : 1; +}; +Quaternion.prototype = { + constructor: Quaternion, + set: function set(x, y, z, w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + return this; + }, + copy: function copy(quaternion) { + this.x = quaternion.x; + this.y = quaternion.y; + this.z = quaternion.z; + this.w = quaternion.w; + return this; + }, + setFromEulerXYZ: function setFromEulerXYZ(x, y, z) { + var c1 = Math.cos(x / 2); + var c2 = Math.cos(y / 2); + var c3 = Math.cos(z / 2); + var s1 = Math.sin(x / 2); + var s2 = Math.sin(y / 2); + var s3 = Math.sin(z / 2); + this.x = s1 * c2 * c3 + c1 * s2 * s3; + this.y = c1 * s2 * c3 - s1 * c2 * s3; + this.z = c1 * c2 * s3 + s1 * s2 * c3; + this.w = c1 * c2 * c3 - s1 * s2 * s3; + return this; + }, + setFromEulerYXZ: function setFromEulerYXZ(x, y, z) { + var c1 = Math.cos(x / 2); + var c2 = Math.cos(y / 2); + var c3 = Math.cos(z / 2); + var s1 = Math.sin(x / 2); + var s2 = Math.sin(y / 2); + var s3 = Math.sin(z / 2); + this.x = s1 * c2 * c3 + c1 * s2 * s3; + this.y = c1 * s2 * c3 - s1 * c2 * s3; + this.z = c1 * c2 * s3 - s1 * s2 * c3; + this.w = c1 * c2 * c3 + s1 * s2 * s3; + return this; + }, + setFromAxisAngle: function setFromAxisAngle(axis, angle) { + var halfAngle = angle / 2, + s = Math.sin(halfAngle); + this.x = axis.x * s; + this.y = axis.y * s; + this.z = axis.z * s; + this.w = Math.cos(halfAngle); + return this; + }, + multiply: function multiply(q) { + return this.multiplyQuaternions(this, q); + }, + multiplyQuaternions: function multiplyQuaternions(a, b) { + var qax = a.x, + qay = a.y, + qaz = a.z, + qaw = a.w; + var qbx = b.x, + qby = b.y, + qbz = b.z, + qbw = b.w; + this.x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby; + this.y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz; + this.z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx; + this.w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz; + return this; + }, + inverse: function inverse() { + this.x *= -1; + this.y *= -1; + this.z *= -1; + this.normalize(); + return this; + }, + normalize: function normalize() { + var l = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w); + if (l === 0) { + this.x = 0; + this.y = 0; + this.z = 0; + this.w = 1; + } else { + l = 1 / l; + this.x = this.x * l; + this.y = this.y * l; + this.z = this.z * l; + this.w = this.w * l; + } + return this; + }, + slerp: function slerp(qb, t) { + if (t === 0) return this; + if (t === 1) return this.copy(qb); + var x = this.x, + y = this.y, + z = this.z, + w = this.w; + var cosHalfTheta = w * qb.w + x * qb.x + y * qb.y + z * qb.z; + if (cosHalfTheta < 0) { + this.w = -qb.w; + this.x = -qb.x; + this.y = -qb.y; + this.z = -qb.z; + cosHalfTheta = -cosHalfTheta; + } else { + this.copy(qb); + } + if (cosHalfTheta >= 1.0) { + this.w = w; + this.x = x; + this.y = y; + this.z = z; + return this; + } + var halfTheta = Math.acos(cosHalfTheta); + var sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta); + if (Math.abs(sinHalfTheta) < 0.001) { + this.w = 0.5 * (w + this.w); + this.x = 0.5 * (x + this.x); + this.y = 0.5 * (y + this.y); + this.z = 0.5 * (z + this.z); + return this; + } + var ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta, + ratioB = Math.sin(t * halfTheta) / sinHalfTheta; + this.w = w * ratioA + this.w * ratioB; + this.x = x * ratioA + this.x * ratioB; + this.y = y * ratioA + this.y * ratioB; + this.z = z * ratioA + this.z * ratioB; + return this; + }, + setFromUnitVectors: function () { + var v1, r; + var EPS = 0.000001; + return function (vFrom, vTo) { + if (v1 === undefined) v1 = new Vector3(); + r = vFrom.dot(vTo) + 1; + if (r < EPS) { + r = 0; + if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) { + v1.set(-vFrom.y, vFrom.x, 0); + } else { + v1.set(0, -vFrom.z, vFrom.y); + } + } else { + v1.crossVectors(vFrom, vTo); + } + this.x = v1.x; + this.y = v1.y; + this.z = v1.z; + this.w = r; + this.normalize(); + return this; + }; + }() +}; +function Device(params) { + this.width = params.width || getScreenWidth(); + this.height = params.height || getScreenHeight(); + this.widthMeters = params.widthMeters; + this.heightMeters = params.heightMeters; + this.bevelMeters = params.bevelMeters; +} +var DEFAULT_ANDROID = new Device({ + widthMeters: 0.110, + heightMeters: 0.062, + bevelMeters: 0.004 +}); +var DEFAULT_IOS = new Device({ + widthMeters: 0.1038, + heightMeters: 0.0584, + bevelMeters: 0.004 +}); +var Viewers = { + CardboardV1: new CardboardViewer({ + id: 'CardboardV1', + label: 'Cardboard I/O 2014', + fov: 40, + interLensDistance: 0.060, + baselineLensDistance: 0.035, + screenLensDistance: 0.042, + distortionCoefficients: [0.441, 0.156], + inverseCoefficients: [-0.4410035, 0.42756155, -0.4804439, 0.5460139, -0.58821183, 0.5733938, -0.48303202, 0.33299083, -0.17573841, 0.0651772, -0.01488963, 0.001559834] + }), + CardboardV2: new CardboardViewer({ + id: 'CardboardV2', + label: 'Cardboard I/O 2015', + fov: 60, + interLensDistance: 0.064, + baselineLensDistance: 0.035, + screenLensDistance: 0.039, + distortionCoefficients: [0.34, 0.55], + inverseCoefficients: [-0.33836704, -0.18162185, 0.862655, -1.2462051, 1.0560602, -0.58208317, 0.21609078, -0.05444823, 0.009177956, -9.904169E-4, 6.183535E-5, -1.6981803E-6] + }) +}; +function DeviceInfo(deviceParams, additionalViewers) { + this.viewer = Viewers.CardboardV2; + this.updateDeviceParams(deviceParams); + this.distortion = new Distortion(this.viewer.distortionCoefficients); + for (var i = 0; i < additionalViewers.length; i++) { + var viewer = additionalViewers[i]; + Viewers[viewer.id] = new CardboardViewer(viewer); + } +} +DeviceInfo.prototype.updateDeviceParams = function (deviceParams) { + this.device = this.determineDevice_(deviceParams) || this.device; +}; +DeviceInfo.prototype.getDevice = function () { + return this.device; +}; +DeviceInfo.prototype.setViewer = function (viewer) { + this.viewer = viewer; + this.distortion = new Distortion(this.viewer.distortionCoefficients); +}; +DeviceInfo.prototype.determineDevice_ = function (deviceParams) { + if (!deviceParams) { + if (isIOS()) { + console.warn('Using fallback iOS device measurements.'); + return DEFAULT_IOS; + } else { + console.warn('Using fallback Android device measurements.'); + return DEFAULT_ANDROID; + } + } + var METERS_PER_INCH = 0.0254; + var metersPerPixelX = METERS_PER_INCH / deviceParams.xdpi; + var metersPerPixelY = METERS_PER_INCH / deviceParams.ydpi; + var width = getScreenWidth(); + var height = getScreenHeight(); + return new Device({ + widthMeters: metersPerPixelX * width, + heightMeters: metersPerPixelY * height, + bevelMeters: deviceParams.bevelMm * 0.001 + }); +}; +DeviceInfo.prototype.getDistortedFieldOfViewLeftEye = function () { + var viewer = this.viewer; + var device = this.device; + var distortion = this.distortion; + var eyeToScreenDistance = viewer.screenLensDistance; + var outerDist = (device.widthMeters - viewer.interLensDistance) / 2; + var innerDist = viewer.interLensDistance / 2; + var bottomDist = viewer.baselineLensDistance - device.bevelMeters; + var topDist = device.heightMeters - bottomDist; + var outerAngle = radToDeg * Math.atan(distortion.distort(outerDist / eyeToScreenDistance)); + var innerAngle = radToDeg * Math.atan(distortion.distort(innerDist / eyeToScreenDistance)); + var bottomAngle = radToDeg * Math.atan(distortion.distort(bottomDist / eyeToScreenDistance)); + var topAngle = radToDeg * Math.atan(distortion.distort(topDist / eyeToScreenDistance)); + return { + leftDegrees: Math.min(outerAngle, viewer.fov), + rightDegrees: Math.min(innerAngle, viewer.fov), + downDegrees: Math.min(bottomAngle, viewer.fov), + upDegrees: Math.min(topAngle, viewer.fov) + }; +}; +DeviceInfo.prototype.getLeftEyeVisibleTanAngles = function () { + var viewer = this.viewer; + var device = this.device; + var distortion = this.distortion; + var fovLeft = Math.tan(-degToRad * viewer.fov); + var fovTop = Math.tan(degToRad * viewer.fov); + var fovRight = Math.tan(degToRad * viewer.fov); + var fovBottom = Math.tan(-degToRad * viewer.fov); + var halfWidth = device.widthMeters / 4; + var halfHeight = device.heightMeters / 2; + var verticalLensOffset = viewer.baselineLensDistance - device.bevelMeters - halfHeight; + var centerX = viewer.interLensDistance / 2 - halfWidth; + var centerY = -verticalLensOffset; + var centerZ = viewer.screenLensDistance; + var screenLeft = distortion.distort((centerX - halfWidth) / centerZ); + var screenTop = distortion.distort((centerY + halfHeight) / centerZ); + var screenRight = distortion.distort((centerX + halfWidth) / centerZ); + var screenBottom = distortion.distort((centerY - halfHeight) / centerZ); + var result = new Float32Array(4); + result[0] = Math.max(fovLeft, screenLeft); + result[1] = Math.min(fovTop, screenTop); + result[2] = Math.min(fovRight, screenRight); + result[3] = Math.max(fovBottom, screenBottom); + return result; +}; +DeviceInfo.prototype.getLeftEyeNoLensTanAngles = function () { + var viewer = this.viewer; + var device = this.device; + var distortion = this.distortion; + var result = new Float32Array(4); + var fovLeft = distortion.distortInverse(Math.tan(-degToRad * viewer.fov)); + var fovTop = distortion.distortInverse(Math.tan(degToRad * viewer.fov)); + var fovRight = distortion.distortInverse(Math.tan(degToRad * viewer.fov)); + var fovBottom = distortion.distortInverse(Math.tan(-degToRad * viewer.fov)); + var halfWidth = device.widthMeters / 4; + var halfHeight = device.heightMeters / 2; + var verticalLensOffset = viewer.baselineLensDistance - device.bevelMeters - halfHeight; + var centerX = viewer.interLensDistance / 2 - halfWidth; + var centerY = -verticalLensOffset; + var centerZ = viewer.screenLensDistance; + var screenLeft = (centerX - halfWidth) / centerZ; + var screenTop = (centerY + halfHeight) / centerZ; + var screenRight = (centerX + halfWidth) / centerZ; + var screenBottom = (centerY - halfHeight) / centerZ; + result[0] = Math.max(fovLeft, screenLeft); + result[1] = Math.min(fovTop, screenTop); + result[2] = Math.min(fovRight, screenRight); + result[3] = Math.max(fovBottom, screenBottom); + return result; +}; +DeviceInfo.prototype.getLeftEyeVisibleScreenRect = function (undistortedFrustum) { + var viewer = this.viewer; + var device = this.device; + var dist = viewer.screenLensDistance; + var eyeX = (device.widthMeters - viewer.interLensDistance) / 2; + var eyeY = viewer.baselineLensDistance - device.bevelMeters; + var left = (undistortedFrustum[0] * dist + eyeX) / device.widthMeters; + var top = (undistortedFrustum[1] * dist + eyeY) / device.heightMeters; + var right = (undistortedFrustum[2] * dist + eyeX) / device.widthMeters; + var bottom = (undistortedFrustum[3] * dist + eyeY) / device.heightMeters; + return { + x: left, + y: bottom, + width: right - left, + height: top - bottom + }; +}; +DeviceInfo.prototype.getFieldOfViewLeftEye = function (opt_isUndistorted) { + return opt_isUndistorted ? this.getUndistortedFieldOfViewLeftEye() : this.getDistortedFieldOfViewLeftEye(); +}; +DeviceInfo.prototype.getFieldOfViewRightEye = function (opt_isUndistorted) { + var fov = this.getFieldOfViewLeftEye(opt_isUndistorted); + return { + leftDegrees: fov.rightDegrees, + rightDegrees: fov.leftDegrees, + upDegrees: fov.upDegrees, + downDegrees: fov.downDegrees + }; +}; +DeviceInfo.prototype.getUndistortedFieldOfViewLeftEye = function () { + var p = this.getUndistortedParams_(); + return { + leftDegrees: radToDeg * Math.atan(p.outerDist), + rightDegrees: radToDeg * Math.atan(p.innerDist), + downDegrees: radToDeg * Math.atan(p.bottomDist), + upDegrees: radToDeg * Math.atan(p.topDist) + }; +}; +DeviceInfo.prototype.getUndistortedViewportLeftEye = function () { + var p = this.getUndistortedParams_(); + var viewer = this.viewer; + var device = this.device; + var eyeToScreenDistance = viewer.screenLensDistance; + var screenWidth = device.widthMeters / eyeToScreenDistance; + var screenHeight = device.heightMeters / eyeToScreenDistance; + var xPxPerTanAngle = device.width / screenWidth; + var yPxPerTanAngle = device.height / screenHeight; + var x = Math.round((p.eyePosX - p.outerDist) * xPxPerTanAngle); + var y = Math.round((p.eyePosY - p.bottomDist) * yPxPerTanAngle); + return { + x: x, + y: y, + width: Math.round((p.eyePosX + p.innerDist) * xPxPerTanAngle) - x, + height: Math.round((p.eyePosY + p.topDist) * yPxPerTanAngle) - y + }; +}; +DeviceInfo.prototype.getUndistortedParams_ = function () { + var viewer = this.viewer; + var device = this.device; + var distortion = this.distortion; + var eyeToScreenDistance = viewer.screenLensDistance; + var halfLensDistance = viewer.interLensDistance / 2 / eyeToScreenDistance; + var screenWidth = device.widthMeters / eyeToScreenDistance; + var screenHeight = device.heightMeters / eyeToScreenDistance; + var eyePosX = screenWidth / 2 - halfLensDistance; + var eyePosY = (viewer.baselineLensDistance - device.bevelMeters) / eyeToScreenDistance; + var maxFov = viewer.fov; + var viewerMax = distortion.distortInverse(Math.tan(degToRad * maxFov)); + var outerDist = Math.min(eyePosX, viewerMax); + var innerDist = Math.min(halfLensDistance, viewerMax); + var bottomDist = Math.min(eyePosY, viewerMax); + var topDist = Math.min(screenHeight - eyePosY, viewerMax); + return { + outerDist: outerDist, + innerDist: innerDist, + topDist: topDist, + bottomDist: bottomDist, + eyePosX: eyePosX, + eyePosY: eyePosY + }; +}; +function CardboardViewer(params) { + this.id = params.id; + this.label = params.label; + this.fov = params.fov; + this.interLensDistance = params.interLensDistance; + this.baselineLensDistance = params.baselineLensDistance; + this.screenLensDistance = params.screenLensDistance; + this.distortionCoefficients = params.distortionCoefficients; + this.inverseCoefficients = params.inverseCoefficients; +} +DeviceInfo.Viewers = Viewers; +var format = 1; +var last_updated = "2018-12-10T17:01:42Z"; +var devices = [{"type":"android","rules":[{"mdmh":"asus/*/Nexus 7/*"},{"ua":"Nexus 7"}],"dpi":[320.8,323],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"asus/*/ASUS_Z00AD/*"},{"ua":"ASUS_Z00AD"}],"dpi":[403,404.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 2 XL/*"},{"ua":"Pixel 2 XL"}],"dpi":537.9,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 3 XL/*"},{"ua":"Pixel 3 XL"}],"dpi":[558.5,553.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel XL/*"},{"ua":"Pixel XL"}],"dpi":[537.9,533],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 3/*"},{"ua":"Pixel 3"}],"dpi":442.4,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 2/*"},{"ua":"Pixel 2"}],"dpi":441,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"Google/*/Pixel/*"},{"ua":"Pixel"}],"dpi":[432.6,436.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"HTC/*/HTC6435LVW/*"},{"ua":"HTC6435LVW"}],"dpi":[449.7,443.3],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One XL/*"},{"ua":"HTC One XL"}],"dpi":[315.3,314.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"htc/*/Nexus 9/*"},{"ua":"Nexus 9"}],"dpi":289,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One M9/*"},{"ua":"HTC One M9"}],"dpi":[442.5,443.3],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One_M8/*"},{"ua":"HTC One_M8"}],"dpi":[449.7,447.4],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One/*"},{"ua":"HTC One"}],"dpi":472.8,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Huawei/*/Nexus 6P/*"},{"ua":"Nexus 6P"}],"dpi":[515.1,518],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Huawei/*/BLN-L24/*"},{"ua":"HONORBLN-L24"}],"dpi":480,"bw":4,"ac":500},{"type":"android","rules":[{"mdmh":"Huawei/*/BKL-L09/*"},{"ua":"BKL-L09"}],"dpi":403,"bw":3.47,"ac":500},{"type":"android","rules":[{"mdmh":"LENOVO/*/Lenovo PB2-690Y/*"},{"ua":"Lenovo PB2-690Y"}],"dpi":[457.2,454.713],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/Nexus 5X/*"},{"ua":"Nexus 5X"}],"dpi":[422,419.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LGMS345/*"},{"ua":"LGMS345"}],"dpi":[221.7,219.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/LG-D800/*"},{"ua":"LG-D800"}],"dpi":[422,424.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/LG-D850/*"},{"ua":"LG-D850"}],"dpi":[537.9,541.9],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/VS985 4G/*"},{"ua":"VS985 4G"}],"dpi":[537.9,535.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/Nexus 5/*"},{"ua":"Nexus 5 B"}],"dpi":[442.4,444.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/Nexus 4/*"},{"ua":"Nexus 4"}],"dpi":[319.8,318.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LG-P769/*"},{"ua":"LG-P769"}],"dpi":[240.6,247.5],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LGMS323/*"},{"ua":"LGMS323"}],"dpi":[206.6,204.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LGLS996/*"},{"ua":"LGLS996"}],"dpi":[403.4,401.5],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Micromax/*/4560MMX/*"},{"ua":"4560MMX"}],"dpi":[240,219.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Micromax/*/A250/*"},{"ua":"Micromax A250"}],"dpi":[480,446.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Micromax/*/Micromax AQ4501/*"},{"ua":"Micromax AQ4501"}],"dpi":240,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/G5/*"},{"ua":"Moto G (5) Plus"}],"dpi":[403.4,403],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/DROID RAZR/*"},{"ua":"DROID RAZR"}],"dpi":[368.1,256.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT830C/*"},{"ua":"XT830C"}],"dpi":[254,255.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1021/*"},{"ua":"XT1021"}],"dpi":[254,256.7],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1023/*"},{"ua":"XT1023"}],"dpi":[254,256.7],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1028/*"},{"ua":"XT1028"}],"dpi":[326.6,327.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1034/*"},{"ua":"XT1034"}],"dpi":[326.6,328.4],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1053/*"},{"ua":"XT1053"}],"dpi":[315.3,316.1],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1562/*"},{"ua":"XT1562"}],"dpi":[403.4,402.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/Nexus 6/*"},{"ua":"Nexus 6 B"}],"dpi":[494.3,489.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1063/*"},{"ua":"XT1063"}],"dpi":[295,296.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1064/*"},{"ua":"XT1064"}],"dpi":[295,295.6],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1092/*"},{"ua":"XT1092"}],"dpi":[422,424.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1095/*"},{"ua":"XT1095"}],"dpi":[422,423.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/G4/*"},{"ua":"Moto G (4)"}],"dpi":401,"bw":4,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/A0001/*"},{"ua":"A0001"}],"dpi":[403.4,401],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONE E1005/*"},{"ua":"ONE E1005"}],"dpi":[442.4,441.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONE A2005/*"},{"ua":"ONE A2005"}],"dpi":[391.9,405.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONEPLUS A5000/*"},{"ua":"ONEPLUS A5000 "}],"dpi":[403.411,399.737],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONE A5010/*"},{"ua":"ONEPLUS A5010"}],"dpi":[403,400],"bw":2,"ac":1000},{"type":"android","rules":[{"mdmh":"OPPO/*/X909/*"},{"ua":"X909"}],"dpi":[442.4,444.1],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9082/*"},{"ua":"GT-I9082"}],"dpi":[184.7,185.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G360P/*"},{"ua":"SM-G360P"}],"dpi":[196.7,205.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/Nexus S/*"},{"ua":"Nexus S"}],"dpi":[234.5,229.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9300/*"},{"ua":"GT-I9300"}],"dpi":[304.8,303.9],"bw":5,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-T230NU/*"},{"ua":"SM-T230NU"}],"dpi":216,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SGH-T399/*"},{"ua":"SGH-T399"}],"dpi":[217.7,231.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SGH-M919/*"},{"ua":"SGH-M919"}],"dpi":[440.8,437.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N9005/*"},{"ua":"SM-N9005"}],"dpi":[386.4,387],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SAMSUNG-SM-N900A/*"},{"ua":"SAMSUNG-SM-N900A"}],"dpi":[386.4,387.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9500/*"},{"ua":"GT-I9500"}],"dpi":[442.5,443.3],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9505/*"},{"ua":"GT-I9505"}],"dpi":439.4,"bw":4,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G900F/*"},{"ua":"SM-G900F"}],"dpi":[415.6,431.6],"bw":5,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G900M/*"},{"ua":"SM-G900M"}],"dpi":[415.6,431.6],"bw":5,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G800F/*"},{"ua":"SM-G800F"}],"dpi":326.8,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G906S/*"},{"ua":"SM-G906S"}],"dpi":[562.7,572.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9300/*"},{"ua":"GT-I9300"}],"dpi":[306.7,304.8],"bw":5,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-T535/*"},{"ua":"SM-T535"}],"dpi":[142.6,136.4],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N920C/*"},{"ua":"SM-N920C"}],"dpi":[515.1,518.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N920P/*"},{"ua":"SM-N920P"}],"dpi":[386.3655,390.144],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N920W8/*"},{"ua":"SM-N920W8"}],"dpi":[515.1,518.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9300I/*"},{"ua":"GT-I9300I"}],"dpi":[304.8,305.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9195/*"},{"ua":"GT-I9195"}],"dpi":[249.4,256.7],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SPH-L520/*"},{"ua":"SPH-L520"}],"dpi":[249.4,255.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SAMSUNG-SGH-I717/*"},{"ua":"SAMSUNG-SGH-I717"}],"dpi":285.8,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SPH-D710/*"},{"ua":"SPH-D710"}],"dpi":[217.7,204.2],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-N7100/*"},{"ua":"GT-N7100"}],"dpi":265.1,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SCH-I605/*"},{"ua":"SCH-I605"}],"dpi":265.1,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/Galaxy Nexus/*"},{"ua":"Galaxy Nexus"}],"dpi":[315.3,314.2],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N910H/*"},{"ua":"SM-N910H"}],"dpi":[515.1,518],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N910C/*"},{"ua":"SM-N910C"}],"dpi":[515.2,520.2],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G130M/*"},{"ua":"SM-G130M"}],"dpi":[165.9,164.8],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G928I/*"},{"ua":"SM-G928I"}],"dpi":[515.1,518.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G920F/*"},{"ua":"SM-G920F"}],"dpi":580.6,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G920P/*"},{"ua":"SM-G920P"}],"dpi":[522.5,577],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G925F/*"},{"ua":"SM-G925F"}],"dpi":580.6,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G925V/*"},{"ua":"SM-G925V"}],"dpi":[522.5,576.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G930F/*"},{"ua":"SM-G930F"}],"dpi":576.6,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G935F/*"},{"ua":"SM-G935F"}],"dpi":533,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G950F/*"},{"ua":"SM-G950F"}],"dpi":[562.707,565.293],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G955U/*"},{"ua":"SM-G955U"}],"dpi":[522.514,525.762],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G955F/*"},{"ua":"SM-G955F"}],"dpi":[522.514,525.762],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"Sony/*/C6903/*"},{"ua":"C6903"}],"dpi":[442.5,443.3],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"Sony/*/D6653/*"},{"ua":"D6653"}],"dpi":[428.6,427.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Sony/*/E6653/*"},{"ua":"E6653"}],"dpi":[428.6,425.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Sony/*/E6853/*"},{"ua":"E6853"}],"dpi":[403.4,401.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Sony/*/SGP321/*"},{"ua":"SGP321"}],"dpi":[224.7,224.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"TCT/*/ALCATEL ONE TOUCH Fierce/*"},{"ua":"ALCATEL ONE TOUCH Fierce"}],"dpi":[240,247.5],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"THL/*/thl 5000/*"},{"ua":"thl 5000"}],"dpi":[480,443.3],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Fly/*/IQ4412/*"},{"ua":"IQ4412"}],"dpi":307.9,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"ZTE/*/ZTE Blade L2/*"},{"ua":"ZTE Blade L2"}],"dpi":240,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"BENEVE/*/VR518/*"},{"ua":"VR518"}],"dpi":480,"bw":3,"ac":500},{"type":"ios","rules":[{"res":[640,960]}],"dpi":[325.1,328.4],"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[640,1136]}],"dpi":[317.1,320.2],"bw":3,"ac":1000},{"type":"ios","rules":[{"res":[750,1334]}],"dpi":326.4,"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[1242,2208]}],"dpi":[453.6,458.4],"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[1125,2001]}],"dpi":[410.9,415.4],"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[1125,2436]}],"dpi":458,"bw":4,"ac":1000}]; +var DPDB_CACHE = { + format: format, + last_updated: last_updated, + devices: devices +}; +function Dpdb(url, onDeviceParamsUpdated) { + this.dpdb = DPDB_CACHE; + this.recalculateDeviceParams_(); + if (url) { + this.onDeviceParamsUpdated = onDeviceParamsUpdated; + var xhr = new XMLHttpRequest(); + var obj = this; + xhr.open('GET', url, true); + xhr.addEventListener('load', function () { + obj.loading = false; + if (xhr.status >= 200 && xhr.status <= 299) { + obj.dpdb = JSON.parse(xhr.response); + obj.recalculateDeviceParams_(); + } else { + console.error('Error loading online DPDB!'); + } + }); + xhr.send(); + } +} +Dpdb.prototype.getDeviceParams = function () { + return this.deviceParams; +}; +Dpdb.prototype.recalculateDeviceParams_ = function () { + var newDeviceParams = this.calcDeviceParams_(); + if (newDeviceParams) { + this.deviceParams = newDeviceParams; + if (this.onDeviceParamsUpdated) { + this.onDeviceParamsUpdated(this.deviceParams); + } + } else { + console.error('Failed to recalculate device parameters.'); + } +}; +Dpdb.prototype.calcDeviceParams_ = function () { + var db = this.dpdb; + if (!db) { + console.error('DPDB not available.'); + return null; + } + if (db.format != 1) { + console.error('DPDB has unexpected format version.'); + return null; + } + if (!db.devices || !db.devices.length) { + console.error('DPDB does not have a devices section.'); + return null; + } + var userAgent = navigator.userAgent || navigator.vendor || window.opera; + var width = getScreenWidth(); + var height = getScreenHeight(); + if (!db.devices) { + console.error('DPDB has no devices section.'); + return null; + } + for (var i = 0; i < db.devices.length; i++) { + var device = db.devices[i]; + if (!device.rules) { + console.warn('Device[' + i + '] has no rules section.'); + continue; + } + if (device.type != 'ios' && device.type != 'android') { + console.warn('Device[' + i + '] has invalid type.'); + continue; + } + if (isIOS() != (device.type == 'ios')) continue; + var matched = false; + for (var j = 0; j < device.rules.length; j++) { + var rule = device.rules[j]; + if (this.ruleMatches_(rule, userAgent, width, height)) { + matched = true; + break; + } + } + if (!matched) continue; + var xdpi = device.dpi[0] || device.dpi; + var ydpi = device.dpi[1] || device.dpi; + return new DeviceParams({ xdpi: xdpi, ydpi: ydpi, bevelMm: device.bw }); + } + console.warn('No DPDB device match.'); + return null; +}; +Dpdb.prototype.ruleMatches_ = function (rule, ua, screenWidth, screenHeight) { + if (!rule.ua && !rule.res) return false; + if (rule.ua && rule.ua.substring(0, 2) === 'SM') rule.ua = rule.ua.substring(0, 7); + if (rule.ua && ua.indexOf(rule.ua) < 0) return false; + if (rule.res) { + if (!rule.res[0] || !rule.res[1]) return false; + var resX = rule.res[0]; + var resY = rule.res[1]; + if (Math.min(screenWidth, screenHeight) != Math.min(resX, resY) || Math.max(screenWidth, screenHeight) != Math.max(resX, resY)) { + return false; + } + } + return true; +}; +function DeviceParams(params) { + this.xdpi = params.xdpi; + this.ydpi = params.ydpi; + this.bevelMm = params.bevelMm; +} +function SensorSample(sample, timestampS) { + this.set(sample, timestampS); +} +SensorSample.prototype.set = function (sample, timestampS) { + this.sample = sample; + this.timestampS = timestampS; +}; +SensorSample.prototype.copy = function (sensorSample) { + this.set(sensorSample.sample, sensorSample.timestampS); +}; +function ComplementaryFilter(kFilter, isDebug) { + this.kFilter = kFilter; + this.isDebug = isDebug; + this.currentAccelMeasurement = new SensorSample(); + this.currentGyroMeasurement = new SensorSample(); + this.previousGyroMeasurement = new SensorSample(); + if (isIOS()) { + this.filterQ = new Quaternion(-1, 0, 0, 1); + } else { + this.filterQ = new Quaternion(1, 0, 0, 1); + } + this.previousFilterQ = new Quaternion(); + this.previousFilterQ.copy(this.filterQ); + this.accelQ = new Quaternion(); + this.isOrientationInitialized = false; + this.estimatedGravity = new Vector3(); + this.measuredGravity = new Vector3(); + this.gyroIntegralQ = new Quaternion(); +} +ComplementaryFilter.prototype.addAccelMeasurement = function (vector, timestampS) { + this.currentAccelMeasurement.set(vector, timestampS); +}; +ComplementaryFilter.prototype.addGyroMeasurement = function (vector, timestampS) { + this.currentGyroMeasurement.set(vector, timestampS); + var deltaT = timestampS - this.previousGyroMeasurement.timestampS; + if (isTimestampDeltaValid(deltaT)) { + this.run_(); + } + this.previousGyroMeasurement.copy(this.currentGyroMeasurement); +}; +ComplementaryFilter.prototype.run_ = function () { + if (!this.isOrientationInitialized) { + this.accelQ = this.accelToQuaternion_(this.currentAccelMeasurement.sample); + this.previousFilterQ.copy(this.accelQ); + this.isOrientationInitialized = true; + return; + } + var deltaT = this.currentGyroMeasurement.timestampS - this.previousGyroMeasurement.timestampS; + var gyroDeltaQ = this.gyroToQuaternionDelta_(this.currentGyroMeasurement.sample, deltaT); + this.gyroIntegralQ.multiply(gyroDeltaQ); + this.filterQ.copy(this.previousFilterQ); + this.filterQ.multiply(gyroDeltaQ); + var invFilterQ = new Quaternion(); + invFilterQ.copy(this.filterQ); + invFilterQ.inverse(); + this.estimatedGravity.set(0, 0, -1); + this.estimatedGravity.applyQuaternion(invFilterQ); + this.estimatedGravity.normalize(); + this.measuredGravity.copy(this.currentAccelMeasurement.sample); + this.measuredGravity.normalize(); + var deltaQ = new Quaternion(); + deltaQ.setFromUnitVectors(this.estimatedGravity, this.measuredGravity); + deltaQ.inverse(); + if (this.isDebug) { + console.log('Delta: %d deg, G_est: (%s, %s, %s), G_meas: (%s, %s, %s)', radToDeg * getQuaternionAngle(deltaQ), this.estimatedGravity.x.toFixed(1), this.estimatedGravity.y.toFixed(1), this.estimatedGravity.z.toFixed(1), this.measuredGravity.x.toFixed(1), this.measuredGravity.y.toFixed(1), this.measuredGravity.z.toFixed(1)); + } + var targetQ = new Quaternion(); + targetQ.copy(this.filterQ); + targetQ.multiply(deltaQ); + this.filterQ.slerp(targetQ, 1 - this.kFilter); + this.previousFilterQ.copy(this.filterQ); +}; +ComplementaryFilter.prototype.getOrientation = function () { + return this.filterQ; +}; +ComplementaryFilter.prototype.accelToQuaternion_ = function (accel) { + var normAccel = new Vector3(); + normAccel.copy(accel); + normAccel.normalize(); + var quat = new Quaternion(); + quat.setFromUnitVectors(new Vector3(0, 0, -1), normAccel); + quat.inverse(); + return quat; +}; +ComplementaryFilter.prototype.gyroToQuaternionDelta_ = function (gyro, dt) { + var quat = new Quaternion(); + var axis = new Vector3(); + axis.copy(gyro); + axis.normalize(); + quat.setFromAxisAngle(axis, gyro.length() * dt); + return quat; +}; +function PosePredictor(predictionTimeS, isDebug) { + this.predictionTimeS = predictionTimeS; + this.isDebug = isDebug; + this.previousQ = new Quaternion(); + this.previousTimestampS = null; + this.deltaQ = new Quaternion(); + this.outQ = new Quaternion(); +} +PosePredictor.prototype.getPrediction = function (currentQ, gyro, timestampS) { + if (!this.previousTimestampS) { + this.previousQ.copy(currentQ); + this.previousTimestampS = timestampS; + return currentQ; + } + var axis = new Vector3(); + axis.copy(gyro); + axis.normalize(); + var angularSpeed = gyro.length(); + if (angularSpeed < degToRad * 20) { + if (this.isDebug) { + console.log('Moving slowly, at %s deg/s: no prediction', (radToDeg * angularSpeed).toFixed(1)); + } + this.outQ.copy(currentQ); + this.previousQ.copy(currentQ); + return this.outQ; + } + var predictAngle = angularSpeed * this.predictionTimeS; + this.deltaQ.setFromAxisAngle(axis, predictAngle); + this.outQ.copy(this.previousQ); + this.outQ.multiply(this.deltaQ); + this.previousQ.copy(currentQ); + this.previousTimestampS = timestampS; + return this.outQ; +}; +function FusionPoseSensor(kFilter, predictionTime, yawOnly, isDebug) { + this.yawOnly = yawOnly; + this.accelerometer = new Vector3(); + this.gyroscope = new Vector3(); + this.filter = new ComplementaryFilter(kFilter, isDebug); + this.posePredictor = new PosePredictor(predictionTime, isDebug); + this.isFirefoxAndroid = isFirefoxAndroid(); + this.isIOS = isIOS(); + var chromeVersion = getChromeVersion(); + this.isDeviceMotionInRadians = !this.isIOS && chromeVersion && chromeVersion < 66; + this.isWithoutDeviceMotion = isChromeWithoutDeviceMotion(); + this.filterToWorldQ = new Quaternion(); + if (isIOS()) { + this.filterToWorldQ.setFromAxisAngle(new Vector3(1, 0, 0), Math.PI / 2); + } else { + this.filterToWorldQ.setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI / 2); + } + this.inverseWorldToScreenQ = new Quaternion(); + this.worldToScreenQ = new Quaternion(); + this.originalPoseAdjustQ = new Quaternion(); + this.originalPoseAdjustQ.setFromAxisAngle(new Vector3(0, 0, 1), -window.orientation * Math.PI / 180); + this.setScreenTransform_(); + if (isLandscapeMode()) { + this.filterToWorldQ.multiply(this.inverseWorldToScreenQ); + } + this.resetQ = new Quaternion(); + this.orientationOut_ = new Float32Array(4); + this.start(); +} +FusionPoseSensor.prototype.getPosition = function () { + return null; +}; +FusionPoseSensor.prototype.getOrientation = function () { + var orientation = void 0; + if (this.isWithoutDeviceMotion && this._deviceOrientationQ) { + this.deviceOrientationFixQ = this.deviceOrientationFixQ || function () { + var z = new Quaternion().setFromAxisAngle(new Vector3(0, 0, -1), 0); + var y = new Quaternion(); + if (window.orientation === -90) { + y.setFromAxisAngle(new Vector3(0, 1, 0), Math.PI / -2); + } else { + y.setFromAxisAngle(new Vector3(0, 1, 0), Math.PI / 2); + } + return z.multiply(y); + }(); + this.deviceOrientationFilterToWorldQ = this.deviceOrientationFilterToWorldQ || function () { + var q = new Quaternion(); + q.setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI / 2); + return q; + }(); + orientation = this._deviceOrientationQ; + var out = new Quaternion(); + out.copy(orientation); + out.multiply(this.deviceOrientationFilterToWorldQ); + out.multiply(this.resetQ); + out.multiply(this.worldToScreenQ); + out.multiplyQuaternions(this.deviceOrientationFixQ, out); + if (this.yawOnly) { + out.x = 0; + out.z = 0; + out.normalize(); + } + this.orientationOut_[0] = out.x; + this.orientationOut_[1] = out.y; + this.orientationOut_[2] = out.z; + this.orientationOut_[3] = out.w; + return this.orientationOut_; + } else { + var filterOrientation = this.filter.getOrientation(); + orientation = this.posePredictor.getPrediction(filterOrientation, this.gyroscope, this.previousTimestampS); + } + var out = new Quaternion(); + out.copy(this.filterToWorldQ); + out.multiply(this.resetQ); + out.multiply(orientation); + out.multiply(this.worldToScreenQ); + if (this.yawOnly) { + out.x = 0; + out.z = 0; + out.normalize(); + } + this.orientationOut_[0] = out.x; + this.orientationOut_[1] = out.y; + this.orientationOut_[2] = out.z; + this.orientationOut_[3] = out.w; + return this.orientationOut_; +}; +FusionPoseSensor.prototype.resetPose = function () { + this.resetQ.copy(this.filter.getOrientation()); + this.resetQ.x = 0; + this.resetQ.y = 0; + this.resetQ.z *= -1; + this.resetQ.normalize(); + if (isLandscapeMode()) { + this.resetQ.multiply(this.inverseWorldToScreenQ); + } + this.resetQ.multiply(this.originalPoseAdjustQ); +}; +FusionPoseSensor.prototype.onDeviceOrientation_ = function (e) { + this._deviceOrientationQ = this._deviceOrientationQ || new Quaternion(); + var alpha = e.alpha, + beta = e.beta, + gamma = e.gamma; + alpha = (alpha || 0) * Math.PI / 180; + beta = (beta || 0) * Math.PI / 180; + gamma = (gamma || 0) * Math.PI / 180; + this._deviceOrientationQ.setFromEulerYXZ(beta, alpha, -gamma); +}; +FusionPoseSensor.prototype.onDeviceMotion_ = function (deviceMotion) { + this.updateDeviceMotion_(deviceMotion); +}; +FusionPoseSensor.prototype.updateDeviceMotion_ = function (deviceMotion) { + var accGravity = deviceMotion.accelerationIncludingGravity; + var rotRate = deviceMotion.rotationRate; + var timestampS = deviceMotion.timeStamp / 1000; + var deltaS = timestampS - this.previousTimestampS; + if (deltaS < 0) { + warnOnce('fusion-pose-sensor:invalid:non-monotonic', 'Invalid timestamps detected: non-monotonic timestamp from devicemotion'); + this.previousTimestampS = timestampS; + return; + } else if (deltaS <= MIN_TIMESTEP || deltaS > MAX_TIMESTEP) { + warnOnce('fusion-pose-sensor:invalid:outside-threshold', 'Invalid timestamps detected: Timestamp from devicemotion outside expected range.'); + this.previousTimestampS = timestampS; + return; + } + this.accelerometer.set(-accGravity.x, -accGravity.y, -accGravity.z); + if (isR7()) { + this.gyroscope.set(-rotRate.beta, rotRate.alpha, rotRate.gamma); + } else { + this.gyroscope.set(rotRate.alpha, rotRate.beta, rotRate.gamma); + } + if (!this.isDeviceMotionInRadians) { + this.gyroscope.multiplyScalar(Math.PI / 180); + } + this.filter.addAccelMeasurement(this.accelerometer, timestampS); + this.filter.addGyroMeasurement(this.gyroscope, timestampS); + this.previousTimestampS = timestampS; +}; +FusionPoseSensor.prototype.onOrientationChange_ = function (screenOrientation) { + this.setScreenTransform_(); +}; +FusionPoseSensor.prototype.onMessage_ = function (event) { + var message = event.data; + if (!message || !message.type) { + return; + } + var type = message.type.toLowerCase(); + if (type !== 'devicemotion') { + return; + } + this.updateDeviceMotion_(message.deviceMotionEvent); +}; +FusionPoseSensor.prototype.setScreenTransform_ = function () { + this.worldToScreenQ.set(0, 0, 0, 1); + switch (window.orientation) { + case 0: + break; + case 90: + this.worldToScreenQ.setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI / 2); + break; + case -90: + this.worldToScreenQ.setFromAxisAngle(new Vector3(0, 0, 1), Math.PI / 2); + break; + case 180: + break; + } + this.inverseWorldToScreenQ.copy(this.worldToScreenQ); + this.inverseWorldToScreenQ.inverse(); +}; +FusionPoseSensor.prototype.start = function () { + this.onDeviceMotionCallback_ = this.onDeviceMotion_.bind(this); + this.onOrientationChangeCallback_ = this.onOrientationChange_.bind(this); + this.onMessageCallback_ = this.onMessage_.bind(this); + this.onDeviceOrientationCallback_ = this.onDeviceOrientation_.bind(this); + if (isIOS() && isInsideCrossOriginIFrame()) { + window.addEventListener('message', this.onMessageCallback_); + } + window.addEventListener('orientationchange', this.onOrientationChangeCallback_); + if (this.isWithoutDeviceMotion) { + window.addEventListener('deviceorientation', this.onDeviceOrientationCallback_); + } else { + window.addEventListener('devicemotion', this.onDeviceMotionCallback_); + } +}; +FusionPoseSensor.prototype.stop = function () { + window.removeEventListener('devicemotion', this.onDeviceMotionCallback_); + window.removeEventListener('deviceorientation', this.onDeviceOrientationCallback_); + window.removeEventListener('orientationchange', this.onOrientationChangeCallback_); + window.removeEventListener('message', this.onMessageCallback_); +}; +var SENSOR_FREQUENCY = 60; +var X_AXIS = new Vector3(1, 0, 0); +var Z_AXIS = new Vector3(0, 0, 1); +var SENSOR_TO_VR = new Quaternion(); +SENSOR_TO_VR.setFromAxisAngle(X_AXIS, -Math.PI / 2); +SENSOR_TO_VR.multiply(new Quaternion().setFromAxisAngle(Z_AXIS, Math.PI / 2)); +var PoseSensor = function () { + function PoseSensor(config) { + classCallCheck(this, PoseSensor); + this.config = config; + this.sensor = null; + this.fusionSensor = null; + this._out = new Float32Array(4); + this.api = null; + this.errors = []; + this._sensorQ = new Quaternion(); + this._outQ = new Quaternion(); + this._onSensorRead = this._onSensorRead.bind(this); + this._onSensorError = this._onSensorError.bind(this); + this.init(); + } + createClass(PoseSensor, [{ + key: 'init', + value: function init() { + var sensor = null; + try { + sensor = new RelativeOrientationSensor({ + frequency: SENSOR_FREQUENCY, + referenceFrame: 'screen' + }); + sensor.addEventListener('error', this._onSensorError); + } catch (error) { + this.errors.push(error); + if (error.name === 'SecurityError') { + console.error('Cannot construct sensors due to the Feature Policy'); + console.warn('Attempting to fall back using "devicemotion"; however this will ' + 'fail in the future without correct permissions.'); + this.useDeviceMotion(); + } else if (error.name === 'ReferenceError') { + this.useDeviceMotion(); + } else { + console.error(error); + } + } + if (sensor) { + this.api = 'sensor'; + this.sensor = sensor; + this.sensor.addEventListener('reading', this._onSensorRead); + this.sensor.start(); + } + } + }, { + key: 'useDeviceMotion', + value: function useDeviceMotion() { + this.api = 'devicemotion'; + this.fusionSensor = new FusionPoseSensor(this.config.K_FILTER, this.config.PREDICTION_TIME_S, this.config.YAW_ONLY, this.config.DEBUG); + if (this.sensor) { + this.sensor.removeEventListener('reading', this._onSensorRead); + this.sensor.removeEventListener('error', this._onSensorError); + this.sensor = null; + } + } + }, { + key: 'getOrientation', + value: function getOrientation() { + if (this.fusionSensor) { + return this.fusionSensor.getOrientation(); + } + if (!this.sensor || !this.sensor.quaternion) { + this._out[0] = this._out[1] = this._out[2] = 0; + this._out[3] = 1; + return this._out; + } + var q = this.sensor.quaternion; + this._sensorQ.set(q[0], q[1], q[2], q[3]); + var out = this._outQ; + out.copy(SENSOR_TO_VR); + out.multiply(this._sensorQ); + if (this.config.YAW_ONLY) { + out.x = out.z = 0; + out.normalize(); + } + this._out[0] = out.x; + this._out[1] = out.y; + this._out[2] = out.z; + this._out[3] = out.w; + return this._out; + } + }, { + key: '_onSensorError', + value: function _onSensorError(event) { + this.errors.push(event.error); + if (event.error.name === 'NotAllowedError') { + console.error('Permission to access sensor was denied'); + } else if (event.error.name === 'NotReadableError') { + console.error('Sensor could not be read'); + } else { + console.error(event.error); + } + this.useDeviceMotion(); + } + }, { + key: '_onSensorRead', + value: function _onSensorRead() {} + }]); + return PoseSensor; +}(); +var rotateInstructionsAsset = ""; +function RotateInstructions() { + this.loadIcon_(); + var overlay = document.createElement('div'); + var s = overlay.style; + s.position = 'fixed'; + s.top = 0; + s.right = 0; + s.bottom = 0; + s.left = 0; + s.backgroundColor = 'gray'; + s.fontFamily = 'sans-serif'; + s.zIndex = 1000000; + var img = document.createElement('img'); + img.src = this.icon; + var s = img.style; + s.marginLeft = '25%'; + s.marginTop = '25%'; + s.width = '50%'; + overlay.appendChild(img); + var text = document.createElement('div'); + var s = text.style; + s.textAlign = 'center'; + s.fontSize = '16px'; + s.lineHeight = '24px'; + s.margin = '24px 25%'; + s.width = '50%'; + text.innerHTML = 'Place your phone into your Cardboard viewer.'; + overlay.appendChild(text); + var snackbar = document.createElement('div'); + var s = snackbar.style; + s.backgroundColor = '#CFD8DC'; + s.position = 'fixed'; + s.bottom = 0; + s.width = '100%'; + s.height = '48px'; + s.padding = '14px 24px'; + s.boxSizing = 'border-box'; + s.color = '#656A6B'; + overlay.appendChild(snackbar); + var snackbarText = document.createElement('div'); + snackbarText.style.float = 'left'; + snackbarText.innerHTML = 'No Cardboard viewer?'; + var snackbarButton = document.createElement('a'); + snackbarButton.href = 'https://www.google.com/get/cardboard/get-cardboard/'; + snackbarButton.innerHTML = 'get one'; + snackbarButton.target = '_blank'; + var s = snackbarButton.style; + s.float = 'right'; + s.fontWeight = 600; + s.textTransform = 'uppercase'; + s.borderLeft = '1px solid gray'; + s.paddingLeft = '24px'; + s.textDecoration = 'none'; + s.color = '#656A6B'; + snackbar.appendChild(snackbarText); + snackbar.appendChild(snackbarButton); + this.overlay = overlay; + this.text = text; + this.hide(); +} +RotateInstructions.prototype.show = function (parent) { + if (!parent && !this.overlay.parentElement) { + document.body.appendChild(this.overlay); + } else if (parent) { + if (this.overlay.parentElement && this.overlay.parentElement != parent) this.overlay.parentElement.removeChild(this.overlay); + parent.appendChild(this.overlay); + } + this.overlay.style.display = 'block'; + var img = this.overlay.querySelector('img'); + var s = img.style; + if (isLandscapeMode()) { + s.width = '20%'; + s.marginLeft = '40%'; + s.marginTop = '3%'; + } else { + s.width = '50%'; + s.marginLeft = '25%'; + s.marginTop = '25%'; + } +}; +RotateInstructions.prototype.hide = function () { + this.overlay.style.display = 'none'; +}; +RotateInstructions.prototype.showTemporarily = function (ms, parent) { + this.show(parent); + this.timer = setTimeout(this.hide.bind(this), ms); +}; +RotateInstructions.prototype.disableShowTemporarily = function () { + clearTimeout(this.timer); +}; +RotateInstructions.prototype.update = function () { + this.disableShowTemporarily(); + if (!isLandscapeMode() && isMobile()) { + this.show(); + } else { + this.hide(); + } +}; +RotateInstructions.prototype.loadIcon_ = function () { + this.icon = dataUri('image/svg+xml', rotateInstructionsAsset); +}; +var DEFAULT_VIEWER = 'CardboardV1'; +var VIEWER_KEY = 'WEBVR_CARDBOARD_VIEWER'; +var CLASS_NAME = 'webvr-polyfill-viewer-selector'; +function ViewerSelector(defaultViewer) { + try { + this.selectedKey = localStorage.getItem(VIEWER_KEY); + } catch (error) { + console.error('Failed to load viewer profile: %s', error); + } + if (!this.selectedKey) { + this.selectedKey = defaultViewer || DEFAULT_VIEWER; + } + this.dialog = this.createDialog_(DeviceInfo.Viewers); + this.root = null; + this.onChangeCallbacks_ = []; +} +ViewerSelector.prototype.show = function (root) { + this.root = root; + root.appendChild(this.dialog); + var selected = this.dialog.querySelector('#' + this.selectedKey); + selected.checked = true; + this.dialog.style.display = 'block'; +}; +ViewerSelector.prototype.hide = function () { + if (this.root && this.root.contains(this.dialog)) { + this.root.removeChild(this.dialog); + } + this.dialog.style.display = 'none'; +}; +ViewerSelector.prototype.getCurrentViewer = function () { + return DeviceInfo.Viewers[this.selectedKey]; +}; +ViewerSelector.prototype.getSelectedKey_ = function () { + var input = this.dialog.querySelector('input[name=field]:checked'); + if (input) { + return input.id; + } + return null; +}; +ViewerSelector.prototype.onChange = function (cb) { + this.onChangeCallbacks_.push(cb); +}; +ViewerSelector.prototype.fireOnChange_ = function (viewer) { + for (var i = 0; i < this.onChangeCallbacks_.length; i++) { + this.onChangeCallbacks_[i](viewer); + } +}; +ViewerSelector.prototype.onSave_ = function () { + this.selectedKey = this.getSelectedKey_(); + if (!this.selectedKey || !DeviceInfo.Viewers[this.selectedKey]) { + console.error('ViewerSelector.onSave_: this should never happen!'); + return; + } + this.fireOnChange_(DeviceInfo.Viewers[this.selectedKey]); + try { + localStorage.setItem(VIEWER_KEY, this.selectedKey); + } catch (error) { + console.error('Failed to save viewer profile: %s', error); + } + this.hide(); +}; +ViewerSelector.prototype.createDialog_ = function (options) { + var container = document.createElement('div'); + container.classList.add(CLASS_NAME); + container.style.display = 'none'; + var overlay = document.createElement('div'); + var s = overlay.style; + s.position = 'fixed'; + s.left = 0; + s.top = 0; + s.width = '100%'; + s.height = '100%'; + s.background = 'rgba(0, 0, 0, 0.3)'; + overlay.addEventListener('click', this.hide.bind(this)); + var width = 280; + var dialog = document.createElement('div'); + var s = dialog.style; + s.boxSizing = 'border-box'; + s.position = 'fixed'; + s.top = '24px'; + s.left = '50%'; + s.marginLeft = -width / 2 + 'px'; + s.width = width + 'px'; + s.padding = '24px'; + s.overflow = 'hidden'; + s.background = '#fafafa'; + s.fontFamily = "'Roboto', sans-serif"; + s.boxShadow = '0px 5px 20px #666'; + dialog.appendChild(this.createH1_('Select your viewer')); + for (var id in options) { + dialog.appendChild(this.createChoice_(id, options[id].label)); + } + dialog.appendChild(this.createButton_('Save', this.onSave_.bind(this))); + container.appendChild(overlay); + container.appendChild(dialog); + return container; +}; +ViewerSelector.prototype.createH1_ = function (name) { + var h1 = document.createElement('h1'); + var s = h1.style; + s.color = 'black'; + s.fontSize = '20px'; + s.fontWeight = 'bold'; + s.marginTop = 0; + s.marginBottom = '24px'; + h1.innerHTML = name; + return h1; +}; +ViewerSelector.prototype.createChoice_ = function (id, name) { + var div = document.createElement('div'); + div.style.marginTop = '8px'; + div.style.color = 'black'; + var input = document.createElement('input'); + input.style.fontSize = '30px'; + input.setAttribute('id', id); + input.setAttribute('type', 'radio'); + input.setAttribute('value', id); + input.setAttribute('name', 'field'); + var label = document.createElement('label'); + label.style.marginLeft = '4px'; + label.setAttribute('for', id); + label.innerHTML = name; + div.appendChild(input); + div.appendChild(label); + return div; +}; +ViewerSelector.prototype.createButton_ = function (label, onclick) { + var button = document.createElement('button'); + button.innerHTML = label; + var s = button.style; + s.float = 'right'; + s.textTransform = 'uppercase'; + s.color = '#1094f7'; + s.fontSize = '14px'; + s.letterSpacing = 0; + s.border = 0; + s.background = 'none'; + s.marginTop = '16px'; + button.addEventListener('click', onclick); + return button; +}; +var commonjsGlobal$$1 = typeof window !== 'undefined' ? window : typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : typeof self !== 'undefined' ? self : {}; +function unwrapExports$$1 (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; +} +function createCommonjsModule$$1(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} +var NoSleep = createCommonjsModule$$1(function (module, exports) { +(function webpackUniversalModuleDefinition(root, factory) { + module.exports = factory(); +})(commonjsGlobal$$1, function() { +return (function(modules) { + var installedModules = {}; + function __webpack_require__(moduleId) { + if(installedModules[moduleId]) { + return installedModules[moduleId].exports; + } + var module = installedModules[moduleId] = { + i: moduleId, + l: false, + exports: {} + }; + modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + module.l = true; + return module.exports; + } + __webpack_require__.m = modules; + __webpack_require__.c = installedModules; + __webpack_require__.d = function(exports, name, getter) { + if(!__webpack_require__.o(exports, name)) { + Object.defineProperty(exports, name, { + configurable: false, + enumerable: true, + get: getter + }); + } + }; + __webpack_require__.n = function(module) { + var getter = module && module.__esModule ? + function getDefault() { return module['default']; } : + function getModuleExports() { return module; }; + __webpack_require__.d(getter, 'a', getter); + return getter; + }; + __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; + __webpack_require__.p = ""; + return __webpack_require__(__webpack_require__.s = 0); + }) + ([ + (function(module, exports, __webpack_require__) { +var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +var mediaFile = __webpack_require__(1); +var oldIOS = typeof navigator !== 'undefined' && parseFloat(('' + (/CPU.*OS ([0-9_]{3,4})[0-9_]{0,1}|(CPU like).*AppleWebKit.*Mobile/i.exec(navigator.userAgent) || [0, ''])[1]).replace('undefined', '3_2').replace('_', '.').replace('_', '')) < 10 && !window.MSStream; +var NoSleep = function () { + function NoSleep() { + _classCallCheck(this, NoSleep); + if (oldIOS) { + this.noSleepTimer = null; + } else { + this.noSleepVideo = document.createElement('video'); + this.noSleepVideo.setAttribute('playsinline', ''); + this.noSleepVideo.setAttribute('src', mediaFile); + this.noSleepVideo.addEventListener('timeupdate', function (e) { + if (this.noSleepVideo.currentTime > 0.5) { + this.noSleepVideo.currentTime = Math.random(); + } + }.bind(this)); + } + } + _createClass(NoSleep, [{ + key: 'enable', + value: function enable() { + if (oldIOS) { + this.disable(); + this.noSleepTimer = window.setInterval(function () { + window.location.href = '/'; + window.setTimeout(window.stop, 0); + }, 15000); + } else { + this.noSleepVideo.play(); + } + } + }, { + key: 'disable', + value: function disable() { + if (oldIOS) { + if (this.noSleepTimer) { + window.clearInterval(this.noSleepTimer); + this.noSleepTimer = null; + } + } else { + this.noSleepVideo.pause(); + } + } + }]); + return NoSleep; +}(); +module.exports = NoSleep; + }), + (function(module, exports, __webpack_require__) { +module.exports = 'data:video/mp4;base64,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'; + }) + ]); +}); +}); +var NoSleep$1 = unwrapExports$$1(NoSleep); +var nextDisplayId = 1000; +var defaultLeftBounds = [0, 0, 0.5, 1]; +var defaultRightBounds = [0.5, 0, 0.5, 1]; +var raf = window.requestAnimationFrame; +var caf = window.cancelAnimationFrame; +function VRFrameData() { + this.leftProjectionMatrix = new Float32Array(16); + this.leftViewMatrix = new Float32Array(16); + this.rightProjectionMatrix = new Float32Array(16); + this.rightViewMatrix = new Float32Array(16); + this.pose = null; +} +function VRDisplayCapabilities(config) { + Object.defineProperties(this, { + hasPosition: { + writable: false, enumerable: true, value: config.hasPosition + }, + hasExternalDisplay: { + writable: false, enumerable: true, value: config.hasExternalDisplay + }, + canPresent: { + writable: false, enumerable: true, value: config.canPresent + }, + maxLayers: { + writable: false, enumerable: true, value: config.maxLayers + }, + hasOrientation: { + enumerable: true, get: function get() { + deprecateWarning('VRDisplayCapabilities.prototype.hasOrientation', 'VRDisplay.prototype.getFrameData'); + return config.hasOrientation; + } + } + }); +} +function VRDisplay(config) { + config = config || {}; + var USE_WAKELOCK = 'wakelock' in config ? config.wakelock : true; + this.isPolyfilled = true; + this.displayId = nextDisplayId++; + this.displayName = ''; + this.depthNear = 0.01; + this.depthFar = 10000.0; + this.isPresenting = false; + Object.defineProperty(this, 'isConnected', { + get: function get() { + deprecateWarning('VRDisplay.prototype.isConnected', 'VRDisplayCapabilities.prototype.hasExternalDisplay'); + return false; + } + }); + this.capabilities = new VRDisplayCapabilities({ + hasPosition: false, + hasOrientation: false, + hasExternalDisplay: false, + canPresent: false, + maxLayers: 1 + }); + this.stageParameters = null; + this.waitingForPresent_ = false; + this.layer_ = null; + this.originalParent_ = null; + this.fullscreenElement_ = null; + this.fullscreenWrapper_ = null; + this.fullscreenElementCachedStyle_ = null; + this.fullscreenEventTarget_ = null; + this.fullscreenChangeHandler_ = null; + this.fullscreenErrorHandler_ = null; + if (USE_WAKELOCK && isMobile()) { + this.wakelock_ = new NoSleep$1(); + } +} +VRDisplay.prototype.getFrameData = function (frameData) { + return frameDataFromPose(frameData, this._getPose(), this); +}; +VRDisplay.prototype.getPose = function () { + deprecateWarning('VRDisplay.prototype.getPose', 'VRDisplay.prototype.getFrameData'); + return this._getPose(); +}; +VRDisplay.prototype.resetPose = function () { + deprecateWarning('VRDisplay.prototype.resetPose'); + return this._resetPose(); +}; +VRDisplay.prototype.getImmediatePose = function () { + deprecateWarning('VRDisplay.prototype.getImmediatePose', 'VRDisplay.prototype.getFrameData'); + return this._getPose(); +}; +VRDisplay.prototype.requestAnimationFrame = function (callback) { + return raf(callback); +}; +VRDisplay.prototype.cancelAnimationFrame = function (id) { + return caf(id); +}; +VRDisplay.prototype.wrapForFullscreen = function (element) { + if (isIOS()) { + return element; + } + if (!this.fullscreenWrapper_) { + this.fullscreenWrapper_ = document.createElement('div'); + var cssProperties = ['height: ' + Math.min(screen.height, screen.width) + 'px !important', 'top: 0 !important', 'left: 0 !important', 'right: 0 !important', 'border: 0', 'margin: 0', 'padding: 0', 'z-index: 999999 !important', 'position: fixed']; + this.fullscreenWrapper_.setAttribute('style', cssProperties.join('; ') + ';'); + this.fullscreenWrapper_.classList.add('webvr-polyfill-fullscreen-wrapper'); + } + if (this.fullscreenElement_ == element) { + return this.fullscreenWrapper_; + } + if (this.fullscreenElement_) { + if (this.originalParent_) { + this.originalParent_.appendChild(this.fullscreenElement_); + } else { + this.fullscreenElement_.parentElement.removeChild(this.fullscreenElement_); + } + } + this.fullscreenElement_ = element; + this.originalParent_ = element.parentElement; + if (!this.originalParent_) { + document.body.appendChild(element); + } + if (!this.fullscreenWrapper_.parentElement) { + var parent = this.fullscreenElement_.parentElement; + parent.insertBefore(this.fullscreenWrapper_, this.fullscreenElement_); + parent.removeChild(this.fullscreenElement_); + } + this.fullscreenWrapper_.insertBefore(this.fullscreenElement_, this.fullscreenWrapper_.firstChild); + this.fullscreenElementCachedStyle_ = this.fullscreenElement_.getAttribute('style'); + var self = this; + function applyFullscreenElementStyle() { + if (!self.fullscreenElement_) { + return; + } + var cssProperties = ['position: absolute', 'top: 0', 'left: 0', 'width: ' + Math.max(screen.width, screen.height) + 'px', 'height: ' + Math.min(screen.height, screen.width) + 'px', 'border: 0', 'margin: 0', 'padding: 0']; + self.fullscreenElement_.setAttribute('style', cssProperties.join('; ') + ';'); + } + applyFullscreenElementStyle(); + return this.fullscreenWrapper_; +}; +VRDisplay.prototype.removeFullscreenWrapper = function () { + if (!this.fullscreenElement_) { + return; + } + var element = this.fullscreenElement_; + if (this.fullscreenElementCachedStyle_) { + element.setAttribute('style', this.fullscreenElementCachedStyle_); + } else { + element.removeAttribute('style'); + } + this.fullscreenElement_ = null; + this.fullscreenElementCachedStyle_ = null; + var parent = this.fullscreenWrapper_.parentElement; + this.fullscreenWrapper_.removeChild(element); + if (this.originalParent_ === parent) { + parent.insertBefore(element, this.fullscreenWrapper_); + } + else if (this.originalParent_) { + this.originalParent_.appendChild(element); + } + parent.removeChild(this.fullscreenWrapper_); + return element; +}; +VRDisplay.prototype.requestPresent = function (layers) { + var wasPresenting = this.isPresenting; + var self = this; + if (!(layers instanceof Array)) { + deprecateWarning('VRDisplay.prototype.requestPresent with non-array argument', 'an array of VRLayers as the first argument'); + layers = [layers]; + } + return new Promise(function (resolve, reject) { + if (!self.capabilities.canPresent) { + reject(new Error('VRDisplay is not capable of presenting.')); + return; + } + if (layers.length == 0 || layers.length > self.capabilities.maxLayers) { + reject(new Error('Invalid number of layers.')); + return; + } + var incomingLayer = layers[0]; + if (!incomingLayer.source) { + resolve(); + return; + } + var leftBounds = incomingLayer.leftBounds || defaultLeftBounds; + var rightBounds = incomingLayer.rightBounds || defaultRightBounds; + if (wasPresenting) { + var layer = self.layer_; + if (layer.source !== incomingLayer.source) { + layer.source = incomingLayer.source; + } + for (var i = 0; i < 4; i++) { + layer.leftBounds[i] = leftBounds[i]; + layer.rightBounds[i] = rightBounds[i]; + } + self.wrapForFullscreen(self.layer_.source); + self.updatePresent_(); + resolve(); + return; + } + self.layer_ = { + predistorted: incomingLayer.predistorted, + source: incomingLayer.source, + leftBounds: leftBounds.slice(0), + rightBounds: rightBounds.slice(0) + }; + self.waitingForPresent_ = false; + if (self.layer_ && self.layer_.source) { + var fullscreenElement = self.wrapForFullscreen(self.layer_.source); + var onFullscreenChange = function onFullscreenChange() { + var actualFullscreenElement = getFullscreenElement(); + self.isPresenting = fullscreenElement === actualFullscreenElement; + if (self.isPresenting) { + if (screen.orientation && screen.orientation.lock) { + screen.orientation.lock('landscape-primary').catch(function (error) { + console.error('screen.orientation.lock() failed due to', error.message); + }); + } + self.waitingForPresent_ = false; + self.beginPresent_(); + resolve(); + } else { + if (screen.orientation && screen.orientation.unlock) { + screen.orientation.unlock(); + } + self.removeFullscreenWrapper(); + self.disableWakeLock(); + self.endPresent_(); + self.removeFullscreenListeners_(); + } + self.fireVRDisplayPresentChange_(); + }; + var onFullscreenError = function onFullscreenError() { + if (!self.waitingForPresent_) { + return; + } + self.removeFullscreenWrapper(); + self.removeFullscreenListeners_(); + self.disableWakeLock(); + self.waitingForPresent_ = false; + self.isPresenting = false; + reject(new Error('Unable to present.')); + }; + self.addFullscreenListeners_(fullscreenElement, onFullscreenChange, onFullscreenError); + if (requestFullscreen(fullscreenElement)) { + self.enableWakeLock(); + self.waitingForPresent_ = true; + } else if (isIOS() || isWebViewAndroid()) { + self.enableWakeLock(); + self.isPresenting = true; + self.beginPresent_(); + self.fireVRDisplayPresentChange_(); + resolve(); + } + } + if (!self.waitingForPresent_ && !isIOS()) { + exitFullscreen(); + reject(new Error('Unable to present.')); + } + }); +}; +VRDisplay.prototype.exitPresent = function () { + var wasPresenting = this.isPresenting; + var self = this; + this.isPresenting = false; + this.layer_ = null; + this.disableWakeLock(); + return new Promise(function (resolve, reject) { + if (wasPresenting) { + if (!exitFullscreen() && isIOS()) { + self.endPresent_(); + self.fireVRDisplayPresentChange_(); + } + if (isWebViewAndroid()) { + self.removeFullscreenWrapper(); + self.removeFullscreenListeners_(); + self.endPresent_(); + self.fireVRDisplayPresentChange_(); + } + resolve(); + } else { + reject(new Error('Was not presenting to VRDisplay.')); + } + }); +}; +VRDisplay.prototype.getLayers = function () { + if (this.layer_) { + return [this.layer_]; + } + return []; +}; +VRDisplay.prototype.fireVRDisplayPresentChange_ = function () { + var event = new CustomEvent('vrdisplaypresentchange', { detail: { display: this } }); + window.dispatchEvent(event); +}; +VRDisplay.prototype.fireVRDisplayConnect_ = function () { + var event = new CustomEvent('vrdisplayconnect', { detail: { display: this } }); + window.dispatchEvent(event); +}; +VRDisplay.prototype.addFullscreenListeners_ = function (element, changeHandler, errorHandler) { + this.removeFullscreenListeners_(); + this.fullscreenEventTarget_ = element; + this.fullscreenChangeHandler_ = changeHandler; + this.fullscreenErrorHandler_ = errorHandler; + if (changeHandler) { + if (document.fullscreenEnabled) { + element.addEventListener('fullscreenchange', changeHandler, false); + } else if (document.webkitFullscreenEnabled) { + element.addEventListener('webkitfullscreenchange', changeHandler, false); + } else if (document.mozFullScreenEnabled) { + document.addEventListener('mozfullscreenchange', changeHandler, false); + } else if (document.msFullscreenEnabled) { + element.addEventListener('msfullscreenchange', changeHandler, false); + } + } + if (errorHandler) { + if (document.fullscreenEnabled) { + element.addEventListener('fullscreenerror', errorHandler, false); + } else if (document.webkitFullscreenEnabled) { + element.addEventListener('webkitfullscreenerror', errorHandler, false); + } else if (document.mozFullScreenEnabled) { + document.addEventListener('mozfullscreenerror', errorHandler, false); + } else if (document.msFullscreenEnabled) { + element.addEventListener('msfullscreenerror', errorHandler, false); + } + } +}; +VRDisplay.prototype.removeFullscreenListeners_ = function () { + if (!this.fullscreenEventTarget_) return; + var element = this.fullscreenEventTarget_; + if (this.fullscreenChangeHandler_) { + var changeHandler = this.fullscreenChangeHandler_; + element.removeEventListener('fullscreenchange', changeHandler, false); + element.removeEventListener('webkitfullscreenchange', changeHandler, false); + document.removeEventListener('mozfullscreenchange', changeHandler, false); + element.removeEventListener('msfullscreenchange', changeHandler, false); + } + if (this.fullscreenErrorHandler_) { + var errorHandler = this.fullscreenErrorHandler_; + element.removeEventListener('fullscreenerror', errorHandler, false); + element.removeEventListener('webkitfullscreenerror', errorHandler, false); + document.removeEventListener('mozfullscreenerror', errorHandler, false); + element.removeEventListener('msfullscreenerror', errorHandler, false); + } + this.fullscreenEventTarget_ = null; + this.fullscreenChangeHandler_ = null; + this.fullscreenErrorHandler_ = null; +}; +VRDisplay.prototype.enableWakeLock = function () { + if (this.wakelock_) { + this.wakelock_.enable(); + } +}; +VRDisplay.prototype.disableWakeLock = function () { + if (this.wakelock_) { + this.wakelock_.disable(); + } +}; +VRDisplay.prototype.beginPresent_ = function () { +}; +VRDisplay.prototype.endPresent_ = function () { +}; +VRDisplay.prototype.submitFrame = function (pose) { +}; +VRDisplay.prototype.getEyeParameters = function (whichEye) { + return null; +}; +var config = { + ADDITIONAL_VIEWERS: [], + DEFAULT_VIEWER: '', + MOBILE_WAKE_LOCK: true, + DEBUG: false, + DPDB_URL: 'https://dpdb.webvr.rocks/dpdb.json', + K_FILTER: 0.98, + PREDICTION_TIME_S: 0.040, + CARDBOARD_UI_DISABLED: false, + ROTATE_INSTRUCTIONS_DISABLED: false, + YAW_ONLY: false, + BUFFER_SCALE: 0.5, + DIRTY_SUBMIT_FRAME_BINDINGS: false +}; +var Eye = { + LEFT: 'left', + RIGHT: 'right' +}; +function CardboardVRDisplay(config$$1) { + var defaults = extend({}, config); + config$$1 = extend(defaults, config$$1 || {}); + VRDisplay.call(this, { + wakelock: config$$1.MOBILE_WAKE_LOCK + }); + this.config = config$$1; + this.displayName = 'Cardboard VRDisplay'; + this.capabilities = new VRDisplayCapabilities({ + hasPosition: false, + hasOrientation: true, + hasExternalDisplay: false, + canPresent: true, + maxLayers: 1 + }); + this.stageParameters = null; + this.bufferScale_ = this.config.BUFFER_SCALE; + this.poseSensor_ = new PoseSensor(this.config); + this.distorter_ = null; + this.cardboardUI_ = null; + this.dpdb_ = new Dpdb(this.config.DPDB_URL, this.onDeviceParamsUpdated_.bind(this)); + this.deviceInfo_ = new DeviceInfo(this.dpdb_.getDeviceParams(), config$$1.ADDITIONAL_VIEWERS); + this.viewerSelector_ = new ViewerSelector(config$$1.DEFAULT_VIEWER); + this.viewerSelector_.onChange(this.onViewerChanged_.bind(this)); + this.deviceInfo_.setViewer(this.viewerSelector_.getCurrentViewer()); + if (!this.config.ROTATE_INSTRUCTIONS_DISABLED) { + this.rotateInstructions_ = new RotateInstructions(); + } + if (isIOS()) { + window.addEventListener('resize', this.onResize_.bind(this)); + } +} +CardboardVRDisplay.prototype = Object.create(VRDisplay.prototype); +CardboardVRDisplay.prototype._getPose = function () { + return { + position: null, + orientation: this.poseSensor_.getOrientation(), + linearVelocity: null, + linearAcceleration: null, + angularVelocity: null, + angularAcceleration: null + }; +}; +CardboardVRDisplay.prototype._resetPose = function () { + if (this.poseSensor_.resetPose) { + this.poseSensor_.resetPose(); + } +}; +CardboardVRDisplay.prototype._getFieldOfView = function (whichEye) { + var fieldOfView; + if (whichEye == Eye.LEFT) { + fieldOfView = this.deviceInfo_.getFieldOfViewLeftEye(); + } else if (whichEye == Eye.RIGHT) { + fieldOfView = this.deviceInfo_.getFieldOfViewRightEye(); + } else { + console.error('Invalid eye provided: %s', whichEye); + return null; + } + return fieldOfView; +}; +CardboardVRDisplay.prototype._getEyeOffset = function (whichEye) { + var offset; + if (whichEye == Eye.LEFT) { + offset = [-this.deviceInfo_.viewer.interLensDistance * 0.5, 0.0, 0.0]; + } else if (whichEye == Eye.RIGHT) { + offset = [this.deviceInfo_.viewer.interLensDistance * 0.5, 0.0, 0.0]; + } else { + console.error('Invalid eye provided: %s', whichEye); + return null; + } + return offset; +}; +CardboardVRDisplay.prototype.getEyeParameters = function (whichEye) { + var offset = this._getEyeOffset(whichEye); + var fieldOfView = this._getFieldOfView(whichEye); + var eyeParams = { + offset: offset, + renderWidth: this.deviceInfo_.device.width * 0.5 * this.bufferScale_, + renderHeight: this.deviceInfo_.device.height * this.bufferScale_ + }; + Object.defineProperty(eyeParams, 'fieldOfView', { + enumerable: true, + get: function get() { + deprecateWarning('VRFieldOfView', 'VRFrameData\'s projection matrices'); + return fieldOfView; + } + }); + return eyeParams; +}; +CardboardVRDisplay.prototype.onDeviceParamsUpdated_ = function (newParams) { + if (this.config.DEBUG) { + console.log('DPDB reported that device params were updated.'); + } + this.deviceInfo_.updateDeviceParams(newParams); + if (this.distorter_) { + this.distorter_.updateDeviceInfo(this.deviceInfo_); + } +}; +CardboardVRDisplay.prototype.updateBounds_ = function () { + if (this.layer_ && this.distorter_ && (this.layer_.leftBounds || this.layer_.rightBounds)) { + this.distorter_.setTextureBounds(this.layer_.leftBounds, this.layer_.rightBounds); + } +}; +CardboardVRDisplay.prototype.beginPresent_ = function () { + var gl = this.layer_.source.getContext('webgl'); + if (!gl) gl = this.layer_.source.getContext('experimental-webgl'); + if (!gl) gl = this.layer_.source.getContext('webgl2'); + if (!gl) return; + if (this.layer_.predistorted) { + if (!this.config.CARDBOARD_UI_DISABLED) { + gl.canvas.width = getScreenWidth() * this.bufferScale_; + gl.canvas.height = getScreenHeight() * this.bufferScale_; + this.cardboardUI_ = new CardboardUI(gl); + } + } else { + if (!this.config.CARDBOARD_UI_DISABLED) { + this.cardboardUI_ = new CardboardUI(gl); + } + this.distorter_ = new CardboardDistorter(gl, this.cardboardUI_, this.config.BUFFER_SCALE, this.config.DIRTY_SUBMIT_FRAME_BINDINGS); + this.distorter_.updateDeviceInfo(this.deviceInfo_); + } + if (this.cardboardUI_) { + this.cardboardUI_.listen(function (e) { + this.viewerSelector_.show(this.layer_.source.parentElement); + e.stopPropagation(); + e.preventDefault(); + }.bind(this), function (e) { + this.exitPresent(); + e.stopPropagation(); + e.preventDefault(); + }.bind(this)); + } + if (this.rotateInstructions_) { + if (isLandscapeMode() && isMobile()) { + this.rotateInstructions_.showTemporarily(3000, this.layer_.source.parentElement); + } else { + this.rotateInstructions_.update(); + } + } + this.orientationHandler = this.onOrientationChange_.bind(this); + window.addEventListener('orientationchange', this.orientationHandler); + this.vrdisplaypresentchangeHandler = this.updateBounds_.bind(this); + window.addEventListener('vrdisplaypresentchange', this.vrdisplaypresentchangeHandler); + this.fireVRDisplayDeviceParamsChange_(); +}; +CardboardVRDisplay.prototype.endPresent_ = function () { + if (this.distorter_) { + this.distorter_.destroy(); + this.distorter_ = null; + } + if (this.cardboardUI_) { + this.cardboardUI_.destroy(); + this.cardboardUI_ = null; + } + if (this.rotateInstructions_) { + this.rotateInstructions_.hide(); + } + this.viewerSelector_.hide(); + window.removeEventListener('orientationchange', this.orientationHandler); + window.removeEventListener('vrdisplaypresentchange', this.vrdisplaypresentchangeHandler); +}; +CardboardVRDisplay.prototype.updatePresent_ = function () { + this.endPresent_(); + this.beginPresent_(); +}; +CardboardVRDisplay.prototype.submitFrame = function (pose) { + if (this.distorter_) { + this.updateBounds_(); + this.distorter_.submitFrame(); + } else if (this.cardboardUI_ && this.layer_) { + var canvas = this.layer_.source.getContext('webgl').canvas; + if (canvas.width != this.lastWidth || canvas.height != this.lastHeight) { + this.cardboardUI_.onResize(); + } + this.lastWidth = canvas.width; + this.lastHeight = canvas.height; + this.cardboardUI_.render(); + } +}; +CardboardVRDisplay.prototype.onOrientationChange_ = function (e) { + this.viewerSelector_.hide(); + if (this.rotateInstructions_) { + this.rotateInstructions_.update(); + } + this.onResize_(); +}; +CardboardVRDisplay.prototype.onResize_ = function (e) { + if (this.layer_) { + var gl = this.layer_.source.getContext('webgl'); + var cssProperties = ['position: absolute', 'top: 0', 'left: 0', + 'width: 100vw', 'height: 100vh', 'border: 0', 'margin: 0', + 'padding: 0px', 'box-sizing: content-box']; + gl.canvas.setAttribute('style', cssProperties.join('; ') + ';'); + safariCssSizeWorkaround(gl.canvas); + } +}; +CardboardVRDisplay.prototype.onViewerChanged_ = function (viewer) { + this.deviceInfo_.setViewer(viewer); + if (this.distorter_) { + this.distorter_.updateDeviceInfo(this.deviceInfo_); + } + this.fireVRDisplayDeviceParamsChange_(); +}; +CardboardVRDisplay.prototype.fireVRDisplayDeviceParamsChange_ = function () { + var event = new CustomEvent('vrdisplaydeviceparamschange', { + detail: { + vrdisplay: this, + deviceInfo: this.deviceInfo_ + } + }); + window.dispatchEvent(event); +}; +CardboardVRDisplay.VRFrameData = VRFrameData; +CardboardVRDisplay.VRDisplay = VRDisplay; +return CardboardVRDisplay; +}))); +}); +var CardboardVRDisplay = unwrapExports(cardboardVrDisplay); + +class XRDevice extends EventTarget { + constructor(global) { + super(); + this.global = global; + this.onWindowResize = this.onWindowResize.bind(this); + this.global.window.addEventListener('resize', this.onWindowResize); + this.environmentBlendMode = 'opaque'; + } + get depthNear() { throw new Error('Not implemented'); } + set depthNear(val) { throw new Error('Not implemented'); } + get depthFar() { throw new Error('Not implemented'); } + set depthFar(val) { throw new Error('Not implemented'); } + onBaseLayerSet(sessionId, layer) { throw new Error('Not implemented'); } + onInlineVerticalFieldOfViewSet(sessionId, value) { throw new Error('Not implemented'); } + supportsSession(mode) { throw new Error('Not implemented'); } + async requestSession(mode) { throw new Error('Not implemented'); } + requestAnimationFrame(callback) { throw new Error('Not implemented'); } + onFrameStart(sessionId) { throw new Error('Not implemented'); } + onFrameEnd(sessionId) { throw new Error('Not implemented'); } + requestStageBounds() { throw new Error('Not implemented'); } + async requestFrameOfReferenceTransform(type, options) { + return undefined; + } + cancelAnimationFrame(handle) { throw new Error('Not implemented'); } + endSession(sessionId) { throw new Error('Not implemented'); } + getViewport(sessionId, eye, layer, target) { throw new Error('Not implemented'); } + getProjectionMatrix(eye) { throw new Error('Not implemented'); } + getBasePoseMatrix() { throw new Error('Not implemented'); } + getBaseViewMatrix(eye) { throw new Error('Not implemented'); } + getInputSources() { throw new Error('Not implemented'); } + getInputPose(inputSource, coordinateSystem, poseType) { throw new Error('Not implemented'); } + onWindowResize() { + this.onWindowResize(); + } +} + +let oculusGo = { + mapping: 'xr-standard', + profiles: ['oculus-go', 'touchpad-controller'], + buttons: { + length: 3, + 0: 1, + 1: null, + 2: 0 + }, + gripTransform: { + orientation: [Math.PI * 0.11, 0, 0, 1] + } +}; +let oculusTouch = { + mapping: 'xr-standard', + displayProfiles: { + 'Oculus Quest': ['oculus-quest', 'oculus-touch', 'thumbstick-controller'] + }, + profiles: ['oculus-touch', 'thumbstick-controller'], + axes: { + length: 4, + 0: null, + 1: null, + 2: 0, + 3: 1 + }, + buttons: { + length: 6, + 0: 1, + 1: 2, + 2: null, + 3: 0, + 4: 3, + 5: 4 + }, + gripTransform: { + position: [0, -0.02, 0.04, 1], + orientation: [Math.PI * 0.11, 0, 0, 1] + } +}; +let openVr = { + mapping: 'xr-standard', + profiles: ['openvr-controller', 'touchpad-controller'], + displayProfiles: { + 'HTC Vive': ['htc-vive', 'touchpad-controller'], + 'HTC Vive DVT': ['htc-vive', 'touchpad-controller'] + }, + buttons: { + length: 3, + 0: 1, + 1: 2, + 2: 0 + }, + gripTransform: { + position: [0, 0, 0.05, 1], + }, + targetRayTransform: { + orientation: [Math.PI * -0.08, 0, 0, 1] + } +}; +let windowsMixedReality = { + mapping: 'xr-standard', + profiles: ['windows-mixed-reality', 'touchpad-thumbstick-controller'], + buttons: { + length: 4, + 0: 1, + 1: 0, + 2: 2, + 3: 4, + }, + gripTransform: { + position: [0, -0.02, 0.04, 1], + orientation: [Math.PI * 0.11, 0, 0, 1] + } +}; +let GamepadMappings = { + 'Oculus Go Controller': oculusGo, + 'Oculus Touch (Right)': oculusTouch, + 'Oculus Touch (Left)': oculusTouch, + 'OpenVR Gamepad': openVr, + 'Windows Mixed Reality (Right)': windowsMixedReality, + 'Windows Mixed Reality (Left)': windowsMixedReality, +}; + +const HEAD_ELBOW_OFFSET_RIGHTHANDED = fromValues$1(0.155, -0.465, -0.15); +const HEAD_ELBOW_OFFSET_LEFTHANDED = fromValues$1(-0.155, -0.465, -0.15); +const ELBOW_WRIST_OFFSET = fromValues$1(0, 0, -0.25); +const WRIST_CONTROLLER_OFFSET = fromValues$1(0, 0, 0.05); +const ARM_EXTENSION_OFFSET = fromValues$1(-0.08, 0.14, 0.08); +const ELBOW_BEND_RATIO = 0.4; +const EXTENSION_RATIO_WEIGHT = 0.4; +const MIN_ANGULAR_SPEED = 0.61; +const MIN_ANGLE_DELTA = 0.175; +const MIN_EXTENSION_COS = 0.12; +const MAX_EXTENSION_COS = 0.87; +const RAD_TO_DEG = 180 / Math.PI; +function eulerFromQuaternion(out, q, order) { + function clamp(value, min$$1, max$$1) { + return (value < min$$1 ? min$$1 : (value > max$$1 ? max$$1 : value)); + } + var sqx = q[0] * q[0]; + var sqy = q[1] * q[1]; + var sqz = q[2] * q[2]; + var sqw = q[3] * q[3]; + if ( order === 'XYZ' ) { + out[0] = Math.atan2( 2 * ( q[0] * q[3] - q[1] * q[2] ), ( sqw - sqx - sqy + sqz ) ); + out[1] = Math.asin( clamp( 2 * ( q[0] * q[2] + q[1] * q[3] ), -1, 1 ) ); + out[2] = Math.atan2( 2 * ( q[2] * q[3] - q[0] * q[1] ), ( sqw + sqx - sqy - sqz ) ); + } else if ( order === 'YXZ' ) { + out[0] = Math.asin( clamp( 2 * ( q[0] * q[3] - q[1] * q[2] ), -1, 1 ) ); + out[1] = Math.atan2( 2 * ( q[0] * q[2] + q[1] * q[3] ), ( sqw - sqx - sqy + sqz ) ); + out[2] = Math.atan2( 2 * ( q[0] * q[1] + q[2] * q[3] ), ( sqw - sqx + sqy - sqz ) ); + } else if ( order === 'ZXY' ) { + out[0] = Math.asin( clamp( 2 * ( q[0] * q[3] + q[1] * q[2] ), -1, 1 ) ); + out[1] = Math.atan2( 2 * ( q[1] * q[3] - q[2] * q[0] ), ( sqw - sqx - sqy + sqz ) ); + out[2] = Math.atan2( 2 * ( q[2] * q[3] - q[0] * q[1] ), ( sqw - sqx + sqy - sqz ) ); + } else if ( order === 'ZYX' ) { + out[0] = Math.atan2( 2 * ( q[0] * q[3] + q[2] * q[1] ), ( sqw - sqx - sqy + sqz ) ); + out[1] = Math.asin( clamp( 2 * ( q[1] * q[3] - q[0] * q[2] ), -1, 1 ) ); + out[2] = Math.atan2( 2 * ( q[0] * q[1] + q[2] * q[3] ), ( sqw + sqx - sqy - sqz ) ); + } else if ( order === 'YZX' ) { + out[0] = Math.atan2( 2 * ( q[0] * q[3] - q[2] * q[1] ), ( sqw - sqx + sqy - sqz ) ); + out[1] = Math.atan2( 2 * ( q[1] * q[3] - q[0] * q[2] ), ( sqw + sqx - sqy - sqz ) ); + out[2] = Math.asin( clamp( 2 * ( q[0] * q[1] + q[2] * q[3] ), -1, 1 ) ); + } else if ( order === 'XZY' ) { + out[0] = Math.atan2( 2 * ( q[0] * q[3] + q[1] * q[2] ), ( sqw - sqx + sqy - sqz ) ); + out[1] = Math.atan2( 2 * ( q[0] * q[2] + q[1] * q[3] ), ( sqw + sqx - sqy - sqz ) ); + out[2] = Math.asin( clamp( 2 * ( q[2] * q[3] - q[0] * q[1] ), -1, 1 ) ); + } else { + console.log('No order given for quaternion to euler conversion.'); + return; + } +} +class OrientationArmModel { + constructor() { + this.hand = 'right'; + this.headElbowOffset = HEAD_ELBOW_OFFSET_RIGHTHANDED; + this.controllerQ = create$4(); + this.lastControllerQ = create$4(); + this.headQ = create$4(); + this.headPos = create$1(); + this.elbowPos = create$1(); + this.wristPos = create$1(); + this.time = null; + this.lastTime = null; + this.rootQ = create$4(); + this.position = create$1(); + } + setHandedness(hand) { + if (this.hand != hand) { + this.hand = hand; + if (this.hand == 'left') { + this.headElbowOffset = HEAD_ELBOW_OFFSET_LEFTHANDED; + } else { + this.headElbowOffset = HEAD_ELBOW_OFFSET_RIGHTHANDED; + } + } + } + update(controllerOrientation, headPoseMatrix) { + this.time = now$1(); + if (controllerOrientation) { + copy$4(this.lastControllerQ, this.controllerQ); + copy$4(this.controllerQ, controllerOrientation); + } + if (headPoseMatrix) { + getTranslation(this.headPos, headPoseMatrix); + getRotation(this.headQ, headPoseMatrix); + } + let headYawQ = this.getHeadYawOrientation_(); + let angleDelta = this.quatAngle_(this.lastControllerQ, this.controllerQ); + let timeDelta = (this.time - this.lastTime) / 1000; + let controllerAngularSpeed = angleDelta / timeDelta; + if (controllerAngularSpeed > MIN_ANGULAR_SPEED) { + slerp(this.rootQ, this.rootQ, headYawQ, + Math.min(angleDelta / MIN_ANGLE_DELTA, 1.0)); + } else { + copy$4(this.rootQ, headYawQ); + } + let controllerForward = fromValues$1(0, 0, -1.0); + transformQuat(controllerForward, controllerForward, this.controllerQ); + let controllerDotY = dot(controllerForward, [0, 1, 0]); + let extensionRatio = this.clamp_( + (controllerDotY - MIN_EXTENSION_COS) / MAX_EXTENSION_COS, 0.0, 1.0); + let controllerCameraQ = clone$4(this.rootQ); + invert$2(controllerCameraQ, controllerCameraQ); + multiply$4(controllerCameraQ, controllerCameraQ, this.controllerQ); + let elbowPos = this.elbowPos; + copy$1(elbowPos, this.headPos); + add$1(elbowPos, elbowPos, this.headElbowOffset); + let elbowOffset = clone$1(ARM_EXTENSION_OFFSET); + scale$1(elbowOffset, elbowOffset, extensionRatio); + add$1(elbowPos, elbowPos, elbowOffset); + let totalAngle = this.quatAngle_(controllerCameraQ, create$4()); + let totalAngleDeg = totalAngle * RAD_TO_DEG; + let lerpSuppression = 1 - Math.pow(totalAngleDeg / 180, 4);let elbowRatio = ELBOW_BEND_RATIO; + let wristRatio = 1 - ELBOW_BEND_RATIO; + let lerpValue = lerpSuppression * + (elbowRatio + wristRatio * extensionRatio * EXTENSION_RATIO_WEIGHT); + let wristQ = create$4(); + slerp(wristQ, wristQ, controllerCameraQ, lerpValue); + let invWristQ = invert$2(create$4(), wristQ); + let elbowQ = clone$4(controllerCameraQ); + multiply$4(elbowQ, elbowQ, invWristQ); + let wristPos = this.wristPos; + copy$1(wristPos, WRIST_CONTROLLER_OFFSET); + transformQuat(wristPos, wristPos, wristQ); + add$1(wristPos, wristPos, ELBOW_WRIST_OFFSET); + transformQuat(wristPos, wristPos, elbowQ); + add$1(wristPos, wristPos, elbowPos); + let offset = clone$1(ARM_EXTENSION_OFFSET); + scale$1(offset, offset, extensionRatio); + add$1(this.position, this.wristPos, offset); + transformQuat(this.position, this.position, this.rootQ); + this.lastTime = this.time; + } + getPosition() { + return this.position; + } + getHeadYawOrientation_() { + let headEuler = create$1(); + eulerFromQuaternion(headEuler, this.headQ, 'YXZ'); + let destinationQ = fromEuler(create$4(), 0, headEuler[1] * RAD_TO_DEG, 0); + return destinationQ; + } + clamp_(value, min$$1, max$$1) { + return Math.min(Math.max(value, min$$1), max$$1); + } + quatAngle_(q1, q2) { + let vec1 = [0, 0, -1]; + let vec2 = [0, 0, -1]; + transformQuat(vec1, vec1, q1); + transformQuat(vec2, vec2, q2); + return angle(vec1, vec2); + } +} + +const PRIVATE$14 = Symbol('@@webxr-polyfill/XRRemappedGamepad'); +const PLACEHOLDER_BUTTON = { pressed: false, touched: false, value: 0.0 }; +Object.freeze(PLACEHOLDER_BUTTON); +class XRRemappedGamepad { + constructor(gamepad, display, map) { + if (!map) { + map = {}; + } + let axes = new Array(map.axes && map.axes.length ? map.axes.length : gamepad.axes.length); + let buttons = new Array(map.buttons && map.buttons.length ? map.buttons.length : gamepad.buttons.length); + let gripTransform = null; + if (map.gripTransform) { + let orientation = map.gripTransform.orientation || [0, 0, 0, 1]; + gripTransform = create(); + fromRotationTranslation( + gripTransform, + normalize$2(orientation, orientation), + map.gripTransform.position || [0, 0, 0] + ); + } + let targetRayTransform = null; + if (map.targetRayTransform) { + let orientation = map.targetRayTransform.orientation || [0, 0, 0, 1]; + targetRayTransform = create(); + fromRotationTranslation( + targetRayTransform, + normalize$2(orientation, orientation), + map.targetRayTransform.position || [0, 0, 0] + ); + } + let profiles = map.profiles; + if (map.displayProfiles) { + if (display.displayName in map.displayProfiles) { + profiles = map.displayProfiles[display.displayName]; + } + } + this[PRIVATE$14] = { + gamepad, + map, + profiles: profiles || [gamepad.id], + mapping: map.mapping || gamepad.mapping, + axes, + buttons, + gripTransform, + targetRayTransform, + }; + this._update(); + } + _update() { + let gamepad = this[PRIVATE$14].gamepad; + let map = this[PRIVATE$14].map; + let axes = this[PRIVATE$14].axes; + for (let i = 0; i < axes.length; ++i) { + if (map.axes && i in map.axes) { + if (map.axes[i] === null) { + axes[i] = 0; + } else { + axes[i] = gamepad.axes[map.axes[i]]; + } + } else { + axes[i] = gamepad.axes[i]; + } + } + if (map.axes && map.axes.invert) { + for (let axis of map.axes.invert) { + axes[axis] *= -1; + } + } + let buttons = this[PRIVATE$14].buttons; + for (let i = 0; i < buttons.length; ++i) { + if (map.buttons && i in map.buttons) { + if (map.buttons[i] === null) { + buttons[i] = PLACEHOLDER_BUTTON; + } else { + buttons[i] = gamepad.buttons[map.buttons[i]]; + } + } else { + buttons[i] = gamepad.buttons[i]; + } + } + } + get id() { + return ''; + } + get _profiles() { + return this[PRIVATE$14].profiles; + } + get index() { + return -1; + } + get connected() { + return this[PRIVATE$14].gamepad.connected; + } + get timestamp() { + return this[PRIVATE$14].gamepad.timestamp; + } + get mapping() { + return this[PRIVATE$14].mapping; + } + get axes() { + return this[PRIVATE$14].axes; + } + get buttons() { + return this[PRIVATE$14].buttons; + } +} +class GamepadXRInputSource { + constructor(polyfill, display, primaryButtonIndex = 0) { + this.polyfill = polyfill; + this.display = display; + this.nativeGamepad = null; + this.gamepad = null; + this.inputSource = new XRInputSource(this); + this.lastPosition = create$1(); + this.emulatedPosition = false; + this.basePoseMatrix = create(); + this.outputMatrix = create(); + this.primaryButtonIndex = primaryButtonIndex; + this.primaryActionPressed = false; + this.handedness = ''; + this.targetRayMode = 'gaze'; + this.armModel = null; + } + get profiles() { + return this.gamepad ? this.gamepad._profiles : []; + } + updateFromGamepad(gamepad) { + if (this.nativeGamepad !== gamepad) { + this.nativeGamepad = gamepad; + if (gamepad) { + this.gamepad = new XRRemappedGamepad(gamepad, this.display, GamepadMappings[gamepad.id]); + } else { + this.gamepad = null; + } + } + this.handedness = gamepad.hand; + if (this.gamepad) { + this.gamepad._update(); + } + if (gamepad.pose) { + this.targetRayMode = 'tracked-pointer'; + this.emulatedPosition = !gamepad.pose.hasPosition; + } else if (gamepad.hand === '') { + this.targetRayMode = 'gaze'; + this.emulatedPosition = false; + } + } + updateBasePoseMatrix() { + if (this.nativeGamepad && this.nativeGamepad.pose) { + let pose = this.nativeGamepad.pose; + let position = pose.position; + let orientation = pose.orientation; + if (!position && !orientation) { + return; + } + if (!position) { + if (!pose.hasPosition) { + if (!this.armModel) { + this.armModel = new OrientationArmModel(); + } + this.armModel.setHandedness(this.nativeGamepad.hand); + this.armModel.update(orientation, this.polyfill.getBasePoseMatrix()); + position = this.armModel.getPosition(); + } else { + position = this.lastPosition; + } + } else { + this.lastPosition[0] = position[0]; + this.lastPosition[1] = position[1]; + this.lastPosition[2] = position[2]; + } + fromRotationTranslation(this.basePoseMatrix, orientation, position); + } else { + copy(this.basePoseMatrix, this.polyfill.getBasePoseMatrix()); + } + return this.basePoseMatrix; + } + getXRPose(coordinateSystem, poseType) { + this.updateBasePoseMatrix(); + switch(poseType) { + case "target-ray": + coordinateSystem._transformBasePoseMatrix(this.outputMatrix, this.basePoseMatrix); + if (this.gamepad && this.gamepad[PRIVATE$14].targetRayTransform) { + multiply(this.outputMatrix, this.outputMatrix, this.gamepad[PRIVATE$14].targetRayTransform); + } + break; + case "grip": + if (!this.nativeGamepad || !this.nativeGamepad.pose) { + return null; + } + coordinateSystem._transformBasePoseMatrix(this.outputMatrix, this.basePoseMatrix); + if (this.gamepad && this.gamepad[PRIVATE$14].gripTransform) { + multiply(this.outputMatrix, this.outputMatrix, this.gamepad[PRIVATE$14].gripTransform); + } + break; + default: + return null; + } + coordinateSystem._adjustForOriginOffset(this.outputMatrix); + return new XRPose(new XRRigidTransform(this.outputMatrix), this.emulatedPosition); + } +} + +const TEST_ENV = "production" === 'test'; +const EXTRA_PRESENTATION_ATTRIBUTES = { + highRefreshRate: true, +}; +const PRIMARY_BUTTON_MAP = { + oculus: 1, + openvr: 1, + 'spatial controller (spatial interaction source)': 1 +}; +let SESSION_ID = 0; +class Session { + constructor(mode, polyfillOptions={}) { + this.mode = mode; + this.outputContext = null; + this.immersive = mode == 'immersive-vr' || mode == 'immersive-ar'; + this.ended = null; + this.baseLayer = null; + this.inlineVerticalFieldOfView = Math.PI * 0.5; + this.id = ++SESSION_ID; + this.modifiedCanvasLayer = false; + if (this.outputContext && !TEST_ENV) { + const renderContextType = polyfillOptions.renderContextType || '2d'; + this.renderContext = this.outputContext.canvas.getContext(renderContextType); + } + } +} +class WebVRDevice extends XRDevice { + constructor(global, display) { + const { canPresent } = display.capabilities; + super(global); + this.display = display; + this.frame = new global.VRFrameData(); + this.sessions = new Map(); + this.immersiveSession = null; + this.canPresent = canPresent; + this.baseModelMatrix = create(); + this.gamepadInputSources = {}; + this.tempVec3 = new Float32Array(3); + this.onVRDisplayPresentChange = this.onVRDisplayPresentChange.bind(this); + global.window.addEventListener('vrdisplaypresentchange', this.onVRDisplayPresentChange); + this.CAN_USE_GAMEPAD = global.navigator && ('getGamepads' in global.navigator); + this.HAS_BITMAP_SUPPORT = isImageBitmapSupported(global); + } + get depthNear() { return this.display.depthNear; } + set depthNear(val) { this.display.depthNear = val; } + get depthFar() { return this.display.depthFar; } + set depthFar(val) { this.display.depthFar = val; } + onBaseLayerSet(sessionId, layer) { + const session = this.sessions.get(sessionId); + const canvas = layer.context.canvas; + if (session.immersive) { + const left = this.display.getEyeParameters('left'); + const right = this.display.getEyeParameters('right'); + canvas.width = Math.max(left.renderWidth, right.renderWidth) * 2; + canvas.height = Math.max(left.renderHeight, right.renderHeight); + this.display.requestPresent([{ + source: canvas, attributes: EXTRA_PRESENTATION_ATTRIBUTES + }]).then(() => { + if (!TEST_ENV && !this.global.document.body.contains(canvas)) { + session.modifiedCanvasLayer = true; + this.global.document.body.appendChild(canvas); + applyCanvasStylesForMinimalRendering(canvas); + } + session.baseLayer = layer; + }); + } + else { + session.baseLayer = layer; + } + } + onInlineVerticalFieldOfViewSet(sessionId, value) { + const session = this.sessions.get(sessionId); + session.inlineVerticalFieldOfView = value; + } + supportsSession(mode) { + if (XRSessionModes.indexOf(mode) == -1) { + throw new TypeError( + `The provided value '${mode}' is not a valid enum value of type XRSessionMode`); + } + if (mode == 'immersive-ar') { + return false; + } + if (mode == 'immersive-vr' && this.canPresent === false) { + return false; + } + return true; + } + async requestSession(mode) { + if (!this.supportsSession(mode)) { + return Promise.reject(); + } + let immersive = mode == 'immersive-vr'; + if (immersive) { + const canvas = this.global.document.createElement('canvas'); + if (!TEST_ENV) { + const ctx = canvas.getContext('webgl'); + } + await this.display.requestPresent([{ + source: canvas, attributes: EXTRA_PRESENTATION_ATTRIBUTES }]); + } + const session = new Session(mode, { + renderContextType: this.HAS_BITMAP_SUPPORT ? 'bitmaprenderer' : '2d' + }); + this.sessions.set(session.id, session); + if (immersive) { + this.immersiveSession = session; + this.dispatchEvent('@@webxr-polyfill/vr-present-start', session.id); + } + return Promise.resolve(session.id); + } + requestAnimationFrame(callback) { + return this.display.requestAnimationFrame(callback); + } + getPrimaryButtonIndex(gamepad) { + let primaryButton = 0; + let name = gamepad.id.toLowerCase(); + for (let key in PRIMARY_BUTTON_MAP) { + if (name.includes(key)) { + primaryButton = PRIMARY_BUTTON_MAP[key]; + break; + } + } + return Math.min(primaryButton, gamepad.buttons.length - 1); + } + onFrameStart(sessionId) { + this.display.getFrameData(this.frame); + const session = this.sessions.get(sessionId); + if (session.immersive && this.CAN_USE_GAMEPAD) { + let prevInputSources = this.gamepadInputSources; + this.gamepadInputSources = {}; + let gamepads = this.global.navigator.getGamepads(); + for (let i = 0; i < gamepads.length; ++i) { + let gamepad = gamepads[i]; + if (gamepad && gamepad.displayId > 0) { + let inputSourceImpl = prevInputSources[i]; + if (!inputSourceImpl) { + inputSourceImpl = new GamepadXRInputSource(this, this.display, this.getPrimaryButtonIndex(gamepad)); + } + inputSourceImpl.updateFromGamepad(gamepad); + this.gamepadInputSources[i] = inputSourceImpl; + if (inputSourceImpl.primaryButtonIndex != -1) { + let primaryActionPressed = gamepad.buttons[inputSourceImpl.primaryButtonIndex].pressed; + if (primaryActionPressed && !inputSourceImpl.primaryActionPressed) { + this.dispatchEvent('@@webxr-polyfill/input-select-start', { sessionId: session.id, inputSource: inputSourceImpl.inputSource }); + } else if (!primaryActionPressed && inputSourceImpl.primaryActionPressed) { + this.dispatchEvent('@@webxr-polyfill/input-select-end', { sessionId: session.id, inputSource: inputSourceImpl.inputSource }); + } + inputSourceImpl.primaryActionPressed = primaryActionPressed; + } + } + } + } + if (TEST_ENV) { + return; + } + if (!session.immersive && session.baseLayer) { + const canvas = session.baseLayer.context.canvas; + perspective(this.frame.leftProjectionMatrix, session.inlineVerticalFieldOfView, + canvas.width/canvas.height, this.depthNear, this.depthFar); + } + } + onFrameEnd(sessionId) { + const session = this.sessions.get(sessionId); + if (session.ended || !session.baseLayer) { + return; + } + if (session.outputContext && + !(session.immersive && !this.display.capabilities.hasExternalDisplay)) { + const mirroring = + session.immersive && this.display.capabilities.hasExternalDisplay; + const iCanvas = session.baseLayer.context.canvas; + const iWidth = mirroring ? iCanvas.width / 2 : iCanvas.width; + const iHeight = iCanvas.height; + if (!TEST_ENV) { + const oCanvas = session.outputContext.canvas; + const oWidth = oCanvas.width; + const oHeight = oCanvas.height; + const renderContext = session.renderContext; + if (this.HAS_BITMAP_SUPPORT) { + if (iCanvas.transferToImageBitmap) { + renderContext.transferFromImageBitmap(iCanvas.transferToImageBitmap()); + } + else { + this.global.createImageBitmap(iCanvas, 0, 0, iWidth, iHeight, { + resizeWidth: oWidth, + resizeHeight: oHeight, + }).then(bitmap => renderContext.transferFromImageBitmap(bitmap)); + } + } else { + renderContext.drawImage(iCanvas, 0, 0, iWidth, iHeight, + 0, 0, oWidth, oHeight); + } + } + } + if (session.immersive && session.baseLayer) { + this.display.submitFrame(); + } + } + cancelAnimationFrame(handle) { + this.display.cancelAnimationFrame(handle); + } + async endSession(sessionId) { + const session = this.sessions.get(sessionId); + if (session.ended) { + return; + } + if (session.immersive) { + return this.display.exitPresent(); + } else { + session.ended = true; + } + } + requestStageBounds() { + if (this.display.stageParameters) { + const width = this.display.stageParameters.sizeX; + const depth = this.display.stageParameters.sizeZ; + const data = []; + data.push(-width / 2); + data.push(-depth / 2); + data.push(width / 2); + data.push(-depth / 2); + data.push(width / 2); + data.push(depth / 2); + data.push(-width / 2); + data.push(depth / 2); + return data; + } + return null; + } + async requestFrameOfReferenceTransform(type, options) { + if ((type === 'local-floor' || type === 'bounded-floor') && + this.display.stageParameters && + this.display.stageParameters.sittingToStandingTransform) { + return this.display.stageParameters.sittingToStandingTransform; + } + return null; + } + getProjectionMatrix(eye) { + if (eye === 'left') { + return this.frame.leftProjectionMatrix; + } else if (eye === 'right') { + return this.frame.rightProjectionMatrix; + } else if (eye === 'none') { + return this.frame.leftProjectionMatrix; + } else { + throw new Error(`eye must be of type 'left' or 'right'`); + } + } + getViewport(sessionId, eye, layer, target) { + const session = this.sessions.get(sessionId); + const { width, height } = layer.context.canvas; + if (!session.immersive) { + target.x = target.y = 0; + target.width = width; + target.height = height; + return true; + } + if (eye === 'left') { + target.x = 0; + } else if (eye === 'right') { + target.x = width / 2; + } else { + return false; + } + target.y = 0; + target.width = width / 2; + target.height = height; + return true; + } + getBasePoseMatrix() { + let { position, orientation } = this.frame.pose; + if (!position && !orientation) { + return this.baseModelMatrix; + } + if (!position) { + position = this.tempVec3; + position[0] = position[1] = position[2] = 0; + } + fromRotationTranslation(this.baseModelMatrix, orientation, position); + return this.baseModelMatrix; + } + getBaseViewMatrix(eye) { + if (eye === 'left') { + return this.frame.leftViewMatrix; + } else if (eye === 'right') { + return this.frame.rightViewMatrix; + } else { + throw new Error(`eye must be of type 'left' or 'right'`); + } + } + getInputSources() { + let inputSources = []; + for (let i in this.gamepadInputSources) { + inputSources.push(this.gamepadInputSources[i].inputSource); + } + return inputSources; + } + getInputPose(inputSource, coordinateSystem, poseType) { + if (!coordinateSystem) { + return null; + } + for (let i in this.gamepadInputSources) { + let inputSourceImpl = this.gamepadInputSources[i]; + if (inputSourceImpl.inputSource === inputSource) { + return inputSourceImpl.getXRPose(coordinateSystem, poseType); + } + } + return null; + } + onWindowResize() { + } + onVRDisplayPresentChange(e) { + if (!this.display.isPresenting) { + this.sessions.forEach(session => { + if (session.immersive && !session.ended) { + if (session.modifiedCanvasLayer) { + const canvas = session.baseLayer.context.canvas; + document.body.removeChild(canvas); + canvas.setAttribute('style', ''); + } + if (this.immersiveSession === session) { + this.immersiveSession = null; + } + this.dispatchEvent('@@webxr-polyfill/vr-present-end', session.id); + } + }); + } + } +} + +class CardboardXRDevice extends WebVRDevice { + constructor(global, cardboardConfig) { + const display = new CardboardVRDisplay(cardboardConfig || {}); + super(global, display); + this.display = display; + this.frame = { + rightViewMatrix: new Float32Array(16), + leftViewMatrix: new Float32Array(16), + rightProjectionMatrix: new Float32Array(16), + leftProjectionMatrix: new Float32Array(16), + pose: null, + timestamp: null, + }; + } +} + +const getWebVRDevice = async function (global) { + let device = null; + if ('getVRDisplays' in global.navigator) { + try { + const displays = await global.navigator.getVRDisplays(); + if (displays && displays.length) { + device = new WebVRDevice(global, displays[0]); + } + } catch (e) {} + } + return device; +}; +const requestXRDevice = async function (global, config) { + if (config.webvr) { + let xr = await getWebVRDevice(global); + if (xr) { + return xr; + } + } + if (!global.VRFrameData) { + global.VRFrameData = function () { + this.rightViewMatrix = new Float32Array(16); + this.leftViewMatrix = new Float32Array(16); + this.rightProjectionMatrix = new Float32Array(16); + this.leftProjectionMatrix = new Float32Array(16); + this.pose = null; + }; + } + return new CardboardXRDevice(global, config.cardboardConfig); +}; + +const CONFIG_DEFAULTS = { + global: _global, + webvr: true, + cardboard: true, + cardboardConfig: null, + allowCardboardOnDesktop: false, +}; +const partials = ['navigator', 'HTMLCanvasElement', 'WebGLRenderingContext']; +class WebXRPolyfill { + constructor(config={}) { + this.config = Object.freeze(Object.assign({}, CONFIG_DEFAULTS, config)); + this.global = this.config.global; + this.nativeWebXR = 'xr' in this.global.navigator; + this.injected = false; + if (!this.nativeWebXR) { + this._injectPolyfill(this.global); + } else { + this._injectCompatibilityShims(this.global); + } + } + _injectPolyfill(global) { + if (!partials.every(iface => !!global[iface])) { + throw new Error(`Global must have the following attributes : ${partials}`); + } + for (const className of Object.keys(API)) { + if (global[className] !== undefined) { + console.warn(`${className} already defined on global.`); + } else { + global[className] = API[className]; + } + } + { + const polyfilledCtx = polyfillMakeXRCompatible(global.WebGLRenderingContext); + if (polyfilledCtx) { + polyfillGetContext(global.HTMLCanvasElement); + if (global.OffscreenCanvas) { + polyfillGetContext(global.OffscreenCanvas); + } + if (global.WebGL2RenderingContext){ + polyfillMakeXRCompatible(global.WebGL2RenderingContext); + } + } + } + this.injected = true; + this._patchNavigatorXR(); + } + _patchNavigatorXR() { + let devicePromise = requestXRDevice(this.global, this.config); + this.xr = new XR(devicePromise); + Object.defineProperty(this.global.navigator, 'xr', { + value: this.xr, + configurable: true, + }); + } + _injectCompatibilityShims(global) { + if (!partials.every(iface => !!global[iface])) { + throw new Error(`Global must have the following attributes : ${partials}`); + } + if (global.XRWebGLLayer) { + let originalRequestSession = global.navigator.xr.requestSession; + global.navigator.xr.requestSession = function(mode, options) { + return originalRequestSession.call(this, mode, options).then((session) => { + session._session_mode = mode; + return session; + }); + }; + var originalXRLayer = global.XRWebGLLayer; + global.XRWebGLLayer = function(session, gl, options) { + if (!options) { + options = {}; + } + options.compositionDisabled = (session._session_mode === "inline"); + return new originalXRLayer(session, gl, options); + }; + } + } +} + +new WebXRPolyfill(); + +} From dee1d7b670ed68bc263b9262fa1b2e750728ab05 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 04:36:42 -0400 Subject: [PATCH 280/562] Small dead code cleanup --- vrarmik.html | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index dabc640..3c3d5e3 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -423,11 +423,8 @@

Examples

buttonMesh.box.setFromCenterAndSize(buttonMesh.getWorldPosition(new THREE.Vector3()), buttonSize.clone().multiply(buttonMesh.getWorldScale(new THREE.Vector3()))); } }; - mesh.getButtonIntersectionIndex = (position, log) => { + mesh.getButtonIntersectionIndex = position => { for (let i = 0; i < buttonMeshes.length; i++) { - if (log) { - console.log('contains', buttonMeshes[i].box.getCenter(new THREE.Vector3()).toArray(), position.toArray()); - } if (buttonMeshes[i].box.containsPoint(position)) { return i; } @@ -769,7 +766,6 @@

Examples

rig.inputs.leftGamepad.position = position; li = mirrorMesh.getButtonIntersectionIndex(position); if (pressed && !lastPressed) { - mirrorMesh.getButtonIntersectionIndex(position, true); if (li !== -1) { aAvatars[li].click(); } @@ -785,7 +781,6 @@

Examples

rig.inputs.rightGamepad.position = position; ri = mirrorMesh.getButtonIntersectionIndex(position); if (pressed && !lastPressed) { - mirrorMesh.getButtonIntersectionIndex(position, true); if (ri !== -1) { aAvatars[ri].click(); } From c38e19dcf8b594562fbd5db9c0607bb94b62362b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 04:37:59 -0400 Subject: [PATCH 281/562] Add model buttons text --- vrarmik.html | 225 +++++++++++++++++++++++++++------------------------ 1 file changed, 121 insertions(+), 104 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 3c3d5e3..98ea5a1 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -379,110 +379,6 @@

Examples

scene.remove(meshes.lowerLegRight); scene.remove(meshes.footRight); */ -const buttonSize = new THREE.Vector3(1, 0.1*0.9, 0.1); -const buttonGeometry = new THREE.BoxBufferGeometry(buttonSize.x, buttonSize.y, buttonSize.z); -const colors = { - normal: 0x5c6bc0, - highlight: 0x303f9f, -}; -const mirrorMesh = (() => { - const geometry = new THREE.PlaneBufferGeometry(1, 2) - .applyMatrix(new THREE.Matrix4().makeTranslation(0, 1, 0)); - const mesh = new THREE.Reflector(geometry, { - clipBias: 0.003, - textureWidth: 1024 * window.devicePixelRatio, - textureHeight: 2048 * window.devicePixelRatio, - color: 0x889999, - addColor: 0x300000, - recursion: 1 - }); - mesh.position.set(0, 0, -1); - - const buttonMeshes = (() => { - const result = Array(5); - for (let i = 0; i < result.length; i++) { - const geometry = buttonGeometry; - const material = new THREE.MeshPhongMaterial({ - color: colors.normal, - }); - const mesh = new THREE.Mesh(geometry, material); - mesh.position.set(-1, 2 - 0.1/2 - i*0.1, 0); - mesh.frustumCulled = false; - mesh.box = new THREE.Box3(); - result[i] = mesh; - } - return result; - })(); - for (let i = 0; i < buttonMeshes.length; i++) { - mesh.add(buttonMeshes[i]); - } - mesh.buttonMeshes = buttonMeshes; - mesh.update = () => { - for (let i = 0; i < buttonMeshes.length; i++) { - const buttonMesh = buttonMeshes[i]; - buttonMesh.box.setFromCenterAndSize(buttonMesh.getWorldPosition(new THREE.Vector3()), buttonSize.clone().multiply(buttonMesh.getWorldScale(new THREE.Vector3()))); - } - }; - mesh.getButtonIntersectionIndex = position => { - for (let i = 0; i < buttonMeshes.length; i++) { - if (buttonMeshes[i].box.containsPoint(position)) { - return i; - } - } - return -1; - }; - - mesh.onBeforeRender2 = () => { - if (model && session) { - model.visible = true; - } - }; - mesh.onAfterRender2 = () => { - if (model && session) { - model.visible = false; - } - }; - - return mesh; -})(); -scene.add(mirrorMesh); - -const userHeight = 1.65; -const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); - -let rig = null; -let model = null; -// let heightOffset = 0; -let heightFactor = 0; -const _rigModel = object => { - if (rig) { - scene.remove(model); - rig = null; - model = null; - } - - model = object; - if (session) { - model.visible = false; - } - rig = new Rig(model); - scene.add(model); - window.model = model; - - // heightOffset = userHeight - rig.height; - heightFactor = rig.height / userHeight; - // console.log('height factor', heightFactor); - - // scene.position.y = heightOffset; - /* model.position.y = -heightOffset; - meshDolly.position.y = -heightOffset; */ - scene.scale.set(1, 1, 1); - mirrorMesh.position.z = -heightFactor; - mirrorMesh.scale.set(1, 1, 1).multiplyScalar(heightFactor); - scene.updateMatrixWorld(); - mirrorMesh.update(); - scene.scale.divideScalar(heightFactor) -}; const _getFileType = filename => { if (/\.(?:gltf|glb|vrm)$/.test(filename)) { return 'gltf'; @@ -706,6 +602,127 @@

Examples

} _loadModelUrl(aAvatars[0].href); +let fontJson, fontTexture; +const fontPromise = Promise.all([ + fetch('DejaVu-sdf.json').then(res => res.json()), + new Promise((accept, reject) => { + new THREE.TextureLoader().load('DejaVu-sdf.png', accept); + }), +]).then(results => { + fontJson = results[0]; + fontTexture = results[1]; +}); +const buttonSize = new THREE.Vector3(1, 0.1*0.9, 0.1); +const buttonGeometry = new THREE.BoxBufferGeometry(buttonSize.x, buttonSize.y, buttonSize.z); +const colors = { + normal: 0x5c6bc0, + highlight: 0x303f9f, +}; +const mirrorMesh = (() => { + const geometry = new THREE.PlaneBufferGeometry(1, 2) + .applyMatrix(new THREE.Matrix4().makeTranslation(0, 1, 0)); + const mesh = new THREE.Reflector(geometry, { + clipBias: 0.003, + textureWidth: 1024 * window.devicePixelRatio, + textureHeight: 2048 * window.devicePixelRatio, + color: 0x889999, + addColor: 0x300000, + recursion: 1 + }); + mesh.position.set(0, 0, -1); + + const buttonMeshes = aAvatars.map((aAvatar, i) => { + const geometry = buttonGeometry; + const material = new THREE.MeshPhongMaterial({ + color: colors.normal, + }); + const mesh = new THREE.Mesh(geometry, material); + mesh.position.set(-1, 2 - 0.1/2 - i*0.1, 0); + mesh.frustumCulled = false; + + fontPromise.then(() => { + const textMesh = _makeTextMesh(aAvatar.innerText, 0xFFFFFF); + textMesh.position.x = -0.45; + textMesh.position.y = -0.02; + textMesh.position.z = 0.06; + mesh.add(textMesh); + }); + + mesh.box = new THREE.Box3(); + + return mesh; + }); + for (let i = 0; i < buttonMeshes.length; i++) { + mesh.add(buttonMeshes[i]); + } + mesh.buttonMeshes = buttonMeshes; + mesh.update = () => { + for (let i = 0; i < buttonMeshes.length; i++) { + const buttonMesh = buttonMeshes[i]; + buttonMesh.box.setFromCenterAndSize(buttonMesh.getWorldPosition(new THREE.Vector3()), buttonSize.clone().multiply(buttonMesh.getWorldScale(new THREE.Vector3()))); + } + }; + mesh.getButtonIntersectionIndex = position => { + for (let i = 0; i < buttonMeshes.length; i++) { + if (buttonMeshes[i].box.containsPoint(position)) { + return i; + } + } + return -1; + }; + + mesh.onBeforeRender2 = () => { + if (model && session) { + model.visible = true; + } + }; + mesh.onAfterRender2 = () => { + if (model && session) { + model.visible = false; + } + }; + + return mesh; +})(); +scene.add(mirrorMesh); + +const userHeight = 1.65; +const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); + +let rig = null; +let model = null; +// let heightOffset = 0; +let heightFactor = 0; +const _rigModel = object => { + if (rig) { + scene.remove(model); + rig = null; + model = null; + } + + model = object; + if (session) { + model.visible = false; + } + rig = new Rig(model); + scene.add(model); + window.model = model; + + // heightOffset = userHeight - rig.height; + heightFactor = rig.height / userHeight; + // console.log('height factor', heightFactor); + + // scene.position.y = heightOffset; + /* model.position.y = -heightOffset; + meshDolly.position.y = -heightOffset; */ + scene.scale.set(1, 1, 1); + mirrorMesh.position.z = -heightFactor; + mirrorMesh.scale.set(1, 1, 1).multiplyScalar(heightFactor); + scene.updateMatrixWorld(); + mirrorMesh.update(); + scene.scale.divideScalar(heightFactor) +}; + const lastPresseds = [false, false]; const realDateNow = (now => () => now())(Date.now);//() => 2000; function animate(timestamp, frame, referenceSpace) { From d134c87e83f6c51d62ebebe2b6d7940f80a50e48 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 17:16:34 -0400 Subject: [PATCH 282/562] Bugfix armature prerotation walk --- vrarmik/Rig.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index f3d125c..32d9125 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -493,7 +493,7 @@ class Rig { for (const k in preRotations) { preRotations[k].inverse(); } - fixSkeletonZForward(skeleton.bones[0], { + fixSkeletonZForward(armature.children[0], { preRotations, }); model.traverse(o => { From ada2180b89bc0d09711327912e17fd22b5037d68 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 17:42:25 -0400 Subject: [PATCH 283/562] Bugfix readAsArrayBuffer call in vrarmik.html --- vrarmik.html | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index 98ea5a1..95f1ec2 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -449,6 +449,14 @@

Examples

throw new Error('no model file in package'); } }; +const _readAsArrayBuffer = blob => new Promise((accept, reject) => { + const reader = new FileReader(); + reader.onload = () => { + accept(reader.result); + }; + reader.onerror = reject; + reader.readAsArrayBuffer(blob); +}); const _loadModelUrl = async (href, filename = href) => { const fileType = _getFileType(filename); if (fileType === 'gltf') { @@ -513,7 +521,7 @@

Examples

const {name} = file; const match = name.match(/^([a-zA-Z0-9]+)\/pathname$/); if (match) { - const pathname = new TextDecoder().decode(await file.blob.arrayBuffer()); + const pathname = new TextDecoder().decode(await _readAsArrayBuffer(file.blob)); const id = match[1]; const assetFileName = `${id}/asset`; const assetFile = files.find(file => file.name === assetFileName); From 25a6bf23626f90444a90650cce08a7677f508288 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 17:44:30 -0400 Subject: [PATCH 284/562] Bugfix flipZ not properly flipping hips --- vrarmik/LegsManager.js | 16 ++-------------- vrarmik/Rig.js | 14 ++++++++++---- vrarmik/ShoulderPoser.js | 24 ++++-------------------- 3 files changed, 16 insertions(+), 38 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 8cdba09..dff36d8 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -112,35 +112,23 @@ class Leg extends MonoBehavior { .add(offsetDirection.clone().multiplyScalar(offsetDistance)); const upperLegDiff = this.upperLeg.position.sub(lowerLegPosition); - if (this.poseManager.flipZ) { - upperLegDiff.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)) - } const upperLegRotation = new Quaternion().setFromRotationMatrix( new THREE.Matrix4().lookAt( new Vector3(), upperLegDiff, - new Vector3(0, 0, this.poseManager.flipZ ? -1 : 1).applyQuaternion(footRotation) + new Vector3(0, 0, 1).applyQuaternion(footRotation) ) ).multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); - if (this.poseManager.flipZ) { - upperLegRotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); - } this.upperLeg.rotation = upperLegRotation; const lowerLegDiff = lowerLegPosition.clone().sub(footPosition); - if (this.poseManager.flipZ) { - lowerLegDiff.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)) - } const lowerLegRotation = new Quaternion().setFromRotationMatrix( new THREE.Matrix4().lookAt( new Vector3(), lowerLegDiff, - new Vector3(0, 0, this.poseManager.flipZ ? -1 : 1).applyQuaternion(footRotation) + new Vector3(0, 0, 1).applyQuaternion(footRotation) ) ).multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); - if (this.poseManager.flipZ) { - lowerLegRotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); - } this.lowerLeg.rotation = lowerLegRotation; // this.lowerLeg.position = lowerLegPosition; diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 32d9125..83e43ad 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -389,6 +389,8 @@ class Rig { const preRotations = { Hips: new Quaternion(), + Hip: new Quaternion(), + J_Bip_C_Hips: new Quaternion(), Left_arm: new Quaternion(), Right_arm: new Quaternion(), Left_elbow: new Quaternion(), @@ -409,7 +411,9 @@ class Rig { HandR: new Quaternion(), }; if (flipY) { - preRotations.Hips.premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); + ['Hips', 'Hip', 'J_Bip_C_Hips'].forEach(k => { + preRotations[k].premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); + }); } if (!flipZ) { // preRotations.Left_arm.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI*0.25)); @@ -417,7 +421,9 @@ class Rig { // preRotations.Upper_armL.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI*0.25)); // preRotations.Upper_armR.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI*0.25)); } else { - preRotations.Hips.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); + ['Hips', 'Hip', 'J_Bip_C_Hips'].forEach(k => { + preRotations[k].premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); + }); } const qr = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2) @@ -743,7 +749,7 @@ class Rig { if (['Left_wrist'].includes(k)) { modelBone.quaternion .premultiply(modelBoneOutput.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.flipZ ? -1 : 1) * Math.PI/2)) // center + .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2)) // center // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up } @@ -766,7 +772,7 @@ class Rig { if (['Right_wrist'].includes(k)) { modelBone.quaternion .premultiply(modelBoneOutput.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.flipZ ? -1 : 1) * -Math.PI/2)) // center + .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // center // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI/8)) // up } modelBone.updateMatrixWorld(); diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 805bee2..1e77d3a 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -107,11 +107,7 @@ class ShoulderPoser extends MonoBehavior updateHips() { const hmdPosition = this.vrTrackingReferences.head.position; const hmdRotation = this.vrTrackingReferences.head.rotation; - if (PoseManager.Instance.flipZ) { - hmdRotation.premultiply(z180Quaternion); - } else { - hmdRotation.multiply(z180Quaternion); - } + hmdRotation.multiply(z180Quaternion); const hmdEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); hmdEuler.x = 0; hmdEuler.z = 0; @@ -132,11 +128,7 @@ class ShoulderPoser extends MonoBehavior updateNeck() { // const hmdPosition = this.vrTrackingReferences.head.position; const hmdRotation = this.vrTrackingReferences.head.rotation; - if (PoseManager.Instance.flipZ) { - hmdRotation.premultiply(z180Quaternion); - } else { - hmdRotation.multiply(z180Quaternion); - } + hmdRotation.multiply(z180Quaternion); const hmdEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); hmdEuler.x = 0; hmdEuler.z = 0; @@ -222,11 +214,7 @@ class ShoulderPoser extends MonoBehavior const relativeHeightDiff = -heightDiff / PoseManager.Instance.playerHeightHmd; const hmdRotation = this.vrTrackingReferences.head.rotation; - if (PoseManager.Instance.flipZ) { - hmdRotation.premultiply(z180Quaternion); - } else { - hmdRotation.multiply(z180Quaternion); - } + hmdRotation.multiply(z180Quaternion); const headRightRotation = VectorHelpers.getAngleBetween(this.shoulder.transform.forward, new Vector3(0, 0, 1).applyQuaternion(hmdRotation), Vector3.up, this.shoulder.transform.right) + this.rightRotationHeadRotationOffset; @@ -293,11 +281,7 @@ class ShoulderPoser extends MonoBehavior clampHeadRotationDeltaUp(targetRotation) { const hmdRotation = this.vrTrackingReferences.head.rotation; - if (PoseManager.Instance.flipZ) { - hmdRotation.premultiply(z180Quaternion); - } else { - hmdRotation.multiply(z180Quaternion); - } + hmdRotation.multiply(z180Quaternion); const headUpRotation = (Transform.eulerAngles(hmdRotation).y + 360) % 360; const targetUpRotation = (targetRotation.y + 360) % 360; From 9d7b6f19dc37ce71c7fa65fe6d8e9c0b73eaa360 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 17:45:29 -0400 Subject: [PATCH 285/562] Bugfix arms flipZ --- vrarmik/Rig.js | 4 ---- vrarmik/VRArmIK.js | 8 +------- 2 files changed, 1 insertion(+), 11 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 83e43ad..b9538b3 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -401,8 +401,6 @@ class Rig { Right_knee: new Quaternion(), */ Upper_legL: new Quaternion(), Upper_legR: new Quaternion(), - ShoulderR: new Quaternion(), - ShoulderL: new Quaternion(), Upper_armL: new Quaternion(), Upper_armR: new Quaternion(), Lower_armR: new Quaternion(), @@ -478,13 +476,11 @@ class Rig { .multiply(ql.clone()) .premultiply(ql2.clone().inverse()); - preRotations.ShoulderR.multiply(armatureQuaternion); preRotations.Upper_armR .multiply(qr.clone().inverse()) preRotations.Lower_armR .multiply(qr.clone()) .premultiply(qr2.clone().inverse()) - preRotations.ShoulderL.multiply(armatureQuaternion); preRotations.Upper_armL .multiply(ql.clone().inverse()) preRotations.Lower_armL diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index ec42793..68b78b0 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -198,16 +198,13 @@ function toPositiveEulerAngle(n) const shoulderRightOffset = this.target.position.sub(this.upperArmPos); - if (PoseManager.Instance.flipZ) { - shoulderRightOffset.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); - } const shoulderRightRotation = new Quaternion().setFromRotationMatrix( new THREE.Matrix4().lookAt( new Vector3(), shoulderRightOffset, new Vector3(0, 1, 0) ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (PoseManager.Instance.flipZ ? -1 : 1) * (this.left ? -1 : 1) * Math.PI/2)); + ).multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.left ? -1 : 1) * Math.PI/2)); // const shoulderRightRotation = new Quaternion().setFromUnitVectors(this.armDirection, targetShoulderDirection); this.setUpperArmRotation(shoulderRightRotation); @@ -398,9 +395,6 @@ function toPositiveEulerAngle(n) this.setWrist2Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .8, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); } const targetRotation = this.target.rotation; - if (PoseManager.Instance.flipZ) { - targetRotation.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)) - } this.setHandRotation(targetRotation); } From 5572395640f95a7bafba1021d3c0dca21f0dc92a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 17:45:44 -0400 Subject: [PATCH 286/562] Remove flipZ variable deep propagation --- vrarmik/PoseManager.js | 1 - vrarmik/Rig.js | 1 - 2 files changed, 2 deletions(-) diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index c89601e..5e502c1 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -22,7 +22,6 @@ class PoseManager extends MonoBehavior this.playerWidthShoulders = 0.31; this.loadPlayerSizeOnAwake = false; - this.flipZ = false; this.flipY = false; PoseManager.Instance = this; diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index b9538b3..71be66d 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -583,7 +583,6 @@ class Rig { const rigObject = new GameObject('rig'); this.poseManager = rigObject.AddComponent(PoseManager); - this.poseManager.flipZ = flipZ; this.poseManager.flipY = flipY; this.shoulderTransforms = rigObject.AddComponent(ShoulderTransforms); this.legsManager = rigObject.AddComponent(LegsManager); From cda39bce78b60b7fa7eb9b690a0a69762f385a15 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 17:46:20 -0400 Subject: [PATCH 287/562] Add leg flip support --- vrarmik/Rig.js | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 71be66d..7364770 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -373,11 +373,14 @@ class Rig { let flipZ = eyeDirection.z < 0; const armatureDirection = new THREE.Vector3(0, 1, 0).applyQuaternion(armature.quaternion); const flipY = armatureDirection.z < -0.5; + const legDirection = new Vector3(0, 0, -1).applyQuaternion(Left_leg.getWorldQuaternion(new Quaternion()).premultiply(armature.quaternion.clone().inverse())); + const flipLeg = legDirection.y < 0.5; const scaleFactor = Head.getWorldPosition(new Vector3()) .distanceTo(Left_ankle.getWorldPosition(new Vector3())) / Math.abs(armature.scale.y) > 100 ? 100 : 1; console.log('flip', flipZ, flipY, scaleFactor, eyeDirection.toArray().join(','), armatureDirection.toArray().join(',')); this.flipZ = flipZ; this.flipY = flipY; + this.flipLeg = flipLeg; this.scaleFactor = scaleFactor; const armatureQuaternion = armature.quaternion.clone(); @@ -423,6 +426,11 @@ class Rig { preRotations[k].premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); }); } + if (flipLeg) { + ['Upper_legR', 'Upper_legL'].forEach(k => { + preRotations[k].premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)); + }); + } const qr = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2) .premultiply( From 7739ca6f210abc000a1d0792d57fbe918be9b8b9 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 19:07:58 -0400 Subject: [PATCH 288/562] Make hair bones relative to armature scale --- vrarmik/Rig.js | 44 +++++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 7364770..2e2d55e 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -293,27 +293,6 @@ class Rig { const Right_ankle = _findFoot(false); const Right_knee = Right_ankle.parent; const Right_leg = Right_knee.parent; - const hairBones = tailBones.filter(bone => /hair/i.test(bone.name)).map(bone => { - for (; bone; bone = bone.parent) { - if (bone.parent === Head) { - return bone; - } - } - return null; - }).filter(bone => bone); - hairBones.forEach(rootHairBone => { - rootHairBone.traverse(hairBone => { - hairBone.length = hairBone.position.length(); - hairBone.worldParentOffset = hairBone.getWorldPosition(new Vector3()).sub(hairBone.parent.getWorldPosition(new Vector3())); - hairBone.initialWorldQuaternion = hairBone.getWorldQuaternion(new Quaternion()); - hairBone.velocity = new Vector3(); - if (hairBone !== rootHairBone) { - hairBone._updateMatrixWorld = hairBone.updateMatrixWorld; - hairBone.updateMatrixWorld = () => {}; - } - }); - }); - this.hairBones = hairBones; const modelBones = { Hips, Spine, @@ -385,11 +364,34 @@ class Rig { const armatureQuaternion = armature.quaternion.clone(); const armatureMatrixInverse = new THREE.Matrix4().getInverse(armature.matrixWorld); + const armatureScale = armature.scale.clone(); armature.position.set(0, 0, 0); armature.quaternion.set(0, 0, 0, 1); armature.scale.set(1, 1, 1).divideScalar(this.scaleFactor); armature.updateMatrix(); + const hairBones = tailBones.filter(bone => /hair/i.test(bone.name)).map(bone => { + for (; bone; bone = bone.parent) { + if (bone.parent === Head) { + return bone; + } + } + return null; + }).filter(bone => bone); + hairBones.forEach(rootHairBone => { + rootHairBone.traverse(hairBone => { + hairBone.length = hairBone.position.length(); + hairBone.worldParentOffset = hairBone.getWorldPosition(new Vector3()).sub(hairBone.parent.getWorldPosition(new Vector3())).divide(armatureScale); + hairBone.initialWorldQuaternion = hairBone.getWorldQuaternion(new Quaternion()); + hairBone.velocity = new Vector3(); + if (hairBone !== rootHairBone) { + hairBone._updateMatrixWorld = hairBone.updateMatrixWorld; + hairBone.updateMatrixWorld = () => {}; + } + }); + }); + this.hairBones = hairBones; + const preRotations = { Hips: new Quaternion(), Hip: new Quaternion(), From e6715ae082cb273f54d5ebe2cde8391510e69f68 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 21:48:41 -0400 Subject: [PATCH 289/562] Add head z testing in vrarmik.html --- vrarmik.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index 95f1ec2..52625bd 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -825,7 +825,7 @@

Examples

// rig.inputs.hmd.position = new Vector3(positionOffset, 0.6 + standFactor, 0); rig.inputs.hmd.position = new Vector3(positionOffset, standFactor, 0); rig.inputs.hmd.rotation = new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle) - .multiply(new Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.25)); + .multiply(new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.25)); rig.inputs.rightGamepad.rotation = new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle); rig.inputs.rightGamepad.position = new Vector3(positionOffset, rig.height*0.7, 0).add( From a7d8e0d237db438befc6fd8ecda6bb952503b66e Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 21:50:23 -0400 Subject: [PATCH 290/562] Auto-detect prerotation bone names --- vrarmik/Rig.js | 69 +++++++++++++++----------------------------------- 1 file changed, 20 insertions(+), 49 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 2e2d55e..03aecc2 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -392,30 +392,17 @@ class Rig { }); this.hairBones = hairBones; - const preRotations = { - Hips: new Quaternion(), - Hip: new Quaternion(), - J_Bip_C_Hips: new Quaternion(), - Left_arm: new Quaternion(), - Right_arm: new Quaternion(), - Left_elbow: new Quaternion(), - Right_elbow: new Quaternion(), - /* Left_ankle: new Quaternion(), - Right_ankle: new Quaternion(), - Left_knee: new Quaternion(), - Right_knee: new Quaternion(), */ - Upper_legL: new Quaternion(), - Upper_legR: new Quaternion(), - Upper_armL: new Quaternion(), - Upper_armR: new Quaternion(), - Lower_armR: new Quaternion(), - Lower_armL: new Quaternion(), - HandL: new Quaternion(), - HandR: new Quaternion(), + const preRotations = {}; + const _ensurePrerotation = k => { + const boneName = modelBones[k].name; + if (!preRotations[boneName]) { + preRotations[boneName] = new Quaternion(); + } + return preRotations[boneName]; }; if (flipY) { - ['Hips', 'Hip', 'J_Bip_C_Hips'].forEach(k => { - preRotations[k].premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); + ['Hips'].forEach(k => { + _ensurePrerotation(k).premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); }); } if (!flipZ) { @@ -424,13 +411,13 @@ class Rig { // preRotations.Upper_armL.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI*0.25)); // preRotations.Upper_armR.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI*0.25)); } else { - ['Hips', 'Hip', 'J_Bip_C_Hips'].forEach(k => { - preRotations[k].premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); + ['Hips'].forEach(k => { + _ensurePrerotation(k).premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); }); } if (flipLeg) { - ['Upper_legR', 'Upper_legL'].forEach(k => { - preRotations[k].premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)); + ['Left_leg', 'Right_leg'].forEach(k => { + _ensurePrerotation(k).premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)); }); } @@ -475,32 +462,19 @@ class Rig { )) ); - preRotations.Right_arm + _ensurePrerotation('Right_arm') .multiply(qr.clone().inverse()); - preRotations.Right_elbow + _ensurePrerotation('Right_elbow') .multiply(qr.clone()) .premultiply(qr2.clone().inverse()); - preRotations.Left_arm + _ensurePrerotation('Left_arm') .multiply(ql.clone().inverse()); - preRotations.Left_elbow + _ensurePrerotation('Left_elbow') .multiply(ql.clone()) .premultiply(ql2.clone().inverse()); - preRotations.Upper_armR - .multiply(qr.clone().inverse()) - preRotations.Lower_armR - .multiply(qr.clone()) - .premultiply(qr2.clone().inverse()) - preRotations.Upper_armL - .multiply(ql.clone().inverse()) - preRotations.Lower_armL - .multiply(ql.clone()) - .premultiply(ql2.clone().inverse()) - - const leftLegQuaternion = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2); - preRotations.Upper_legL.premultiply(leftLegQuaternion); - const rightLegQuaternion = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2); - preRotations.Upper_legR.premultiply(rightLegQuaternion); + _ensurePrerotation('Left_leg').premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); + _ensurePrerotation('Right_leg').premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); for (const k in preRotations) { preRotations[k].inverse(); @@ -515,10 +489,7 @@ class Rig { }); if (flipY) { ['Hips'].forEach(name => { - const bone = modelBones[name]; - if (bone) { - bone.quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); - } + modelBones[name].quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); }); } if (!flipZ) { From 0fbb959c65f308138065e2a421cfd8989cd67c00 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 21:51:09 -0400 Subject: [PATCH 291/562] Small model bones lookup cleanup --- vrarmik/Rig.js | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 03aecc2..4ed6786 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -501,10 +501,7 @@ class Rig { }); */ } else { ['Hips'].forEach(name => { - const bone = modelBones[name]; - if (bone) { - bone.quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); - } + modelBones[name].quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); }); } if (preRotations.Right_arm.applied || preRotations.Upper_armR.applied) { From 0383c5a8d4a0e8d53b44f0c297000a2a7460a9a0 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 21:51:31 -0400 Subject: [PATCH 292/562] Always apply arm prerotation post --- vrarmik/Rig.js | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 4ed6786..6eaf285 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -504,7 +504,7 @@ class Rig { modelBones[name].quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); }); } - if (preRotations.Right_arm.applied || preRotations.Upper_armR.applied) { + // if ((preRotations.Right_arm && preRotations.Right_arm.applied) || (preRotations.Upper_armR && preRotations.Upper_armR.applied)) { modelBones.Right_arm.quaternion.premultiply(qr.clone().inverse()); modelBones.Right_elbow.quaternion .premultiply(qr) @@ -513,7 +513,10 @@ class Rig { modelBones.Left_elbow.quaternion .premultiply(ql) .premultiply(ql2.clone().inverse()); - } + console.log('log yes', flipZ, flipY, flipLeg); + /* } else { + console.log('log no', flipZ, flipY, flipLeg); + } */ model.updateMatrixWorld(true); for (let i = 0; i < skeleton.bones.length; i++) { From b3c11f09242ce3e1db2d398ff54574a8ec47d34d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 21:52:06 -0400 Subject: [PATCH 293/562] Handle arm prerotation angles for flip z --- vrarmik/Rig.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 6eaf285..2968f22 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -421,7 +421,7 @@ class Rig { }); } - const qr = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2) + const qr = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * -Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), @@ -431,7 +431,7 @@ class Rig { new Vector3(0, 1, 0), )) ); - const qr2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2) + const qr2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * -Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), @@ -441,7 +441,7 @@ class Rig { new Vector3(0, 1, 0), )) ); - const ql = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2) + const ql = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), @@ -451,7 +451,7 @@ class Rig { new Vector3(0, 1, 0), )) ); - const ql2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2) + const ql2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), From 3c24335a40553625d6c140f2ff5b509210baf7a9 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sat, 26 Oct 2019 22:32:19 -0400 Subject: [PATCH 294/562] Clean up hands behind head detection --- vrarmik/ShoulderPoser.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 1e77d3a..f7e5520 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -267,7 +267,9 @@ class ShoulderPoser extends MonoBehavior const delta = Mathf.Abs(targetRotation.y - this.lastAngle.y + 360) % 360; if (delta > 150 && delta < 210 && this.lastAngle.magnitude > 0.000001 && !this.clampingHeadRotation) { - this.handsBehindHead = !this.handsBehindHead; + this.handsBehindHead = true; + } else { + this.handsBehindHead = false; } this.lastAngle = targetRotation; From e5a8b393170a280fb76f9070d066343f8a6f98e4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 00:44:02 -0400 Subject: [PATCH 295/562] Remove initial hands behind head --- vrarmik/ShoulderPoser.js | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index f7e5520..841ef95 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -194,10 +194,10 @@ class ShoulderPoser extends MonoBehavior const targetRotation = new Vector3(0, angle, 0); - if (this.autoDetectHandsBehindHead) + /* if (this.autoDetectHandsBehindHead) { this.detectHandsBehindHead(targetRotation); - } + } */ if (this.clampRotationToHead) { @@ -267,9 +267,7 @@ class ShoulderPoser extends MonoBehavior const delta = Mathf.Abs(targetRotation.y - this.lastAngle.y + 360) % 360; if (delta > 150 && delta < 210 && this.lastAngle.magnitude > 0.000001 && !this.clampingHeadRotation) { - this.handsBehindHead = true; - } else { - this.handsBehindHead = false; + this.handsBehindHead = !this.handsBehindHead; } this.lastAngle = targetRotation; From 5c554f91e9ed98f23389dd163585204253bcd0e9 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 00:57:35 -0400 Subject: [PATCH 296/562] Small arm IK jitter cleanup --- vrarmik/VRArmIK.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 68b78b0..41f23ad 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -131,8 +131,8 @@ function toPositiveEulerAngle(n) if (this.elbowSettings.calcElbowAngle) { this.positionElbow(); - if (this.elbowCorrectionSettings.useFixedElbowWhenNearShoulder) - this.correctElbowAfterPositioning(); + /* if (this.elbowCorrectionSettings.useFixedElbowWhenNearShoulder) + this.correctElbowAfterPositioning(); */ if (this.handSettings.rotateElbowWithHandRight) this.rotateElbowWithHandRight(); if (this.handSettings.rotateElbowWithHandForward) From ac9bccbb8f54c1a05de16833a21264baf46498cf Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 00:58:00 -0400 Subject: [PATCH 297/562] Major bugfixing in arms behind head case --- vrarmik/ShoulderPoser.js | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 841ef95..d221fc0 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -252,6 +252,41 @@ class ShoulderPoser extends MonoBehavior distanceRightHand.y = 0; } + const hmdRotation = this.vrTrackingReferences.head.rotation; + const hmdEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); + hmdEuler.x = 0; + hmdEuler.z = 0; + const hmdFlatRotation = new Quaternion().setFromEuler(hmdEuler); + const hmdFlatRotationInverse = hmdFlatRotation.clone().inverse(); + + const leftHandBehind = distanceLeftHand.clone().applyQuaternion(hmdFlatRotationInverse); + const leftBehind = leftHandBehind.z > 0; + const rightHandBehind = distanceRightHand.clone().applyQuaternion(hmdFlatRotationInverse); + const rightBehind = rightHandBehind.z > 0; + + if (leftBehind) { + /* if (leftHandBehind.x < 0) { + leftHandBehind.x *= -1; + } else { */ + leftHandBehind.x = 0; + // } + leftHandBehind.y = 0; + leftHandBehind.z *= rightBehind ? -2 : -1; + leftHandBehind.applyQuaternion(hmdFlatRotation); + distanceLeftHand.add(leftHandBehind); + } + if (rightBehind) { + /* if (rightHandBehind.x > 0) { + rightHandBehind.x *= -1; + } else { */ + rightHandBehind.x = 0; + // } + rightHandBehind.y = 0; + rightHandBehind.z *= leftBehind ? -2 : -1; + rightHandBehind.applyQuaternion(hmdFlatRotation); + distanceRightHand.add(rightHandBehind); + } + const directionLeftHand = distanceLeftHand.normalized; const directionRightHand = distanceRightHand.normalized; From db562f7cd98402c36f8c95380e72600bbbf990f3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 01:21:22 -0400 Subject: [PATCH 298/562] Bugfix hand target rotation --- vrarmik/VRArmIK.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 41f23ad..ad82dca 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -394,7 +394,7 @@ function toPositiveEulerAngle(n) if (this.arm.wrist2 !== null) this.setWrist2Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .8, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); } - const targetRotation = this.target.rotation; + const targetRotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); this.setHandRotation(targetRotation); } From 1e14c408ea9e5ec2ca3f3c1f0782f3e52b9f856a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 01:38:33 -0400 Subject: [PATCH 299/562] Rig.js dead code cleanup --- vrarmik/Rig.js | 21 ++++++++------------- 1 file changed, 8 insertions(+), 13 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 2968f22..9ff9910 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -504,19 +504,14 @@ class Rig { modelBones[name].quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); }); } - // if ((preRotations.Right_arm && preRotations.Right_arm.applied) || (preRotations.Upper_armR && preRotations.Upper_armR.applied)) { - modelBones.Right_arm.quaternion.premultiply(qr.clone().inverse()); - modelBones.Right_elbow.quaternion - .premultiply(qr) - .premultiply(qr2.clone().inverse()); - modelBones.Left_arm.quaternion.premultiply(ql.clone().inverse()); - modelBones.Left_elbow.quaternion - .premultiply(ql) - .premultiply(ql2.clone().inverse()); - console.log('log yes', flipZ, flipY, flipLeg); - /* } else { - console.log('log no', flipZ, flipY, flipLeg); - } */ + modelBones.Right_arm.quaternion.premultiply(qr.clone().inverse()); + modelBones.Right_elbow.quaternion + .premultiply(qr) + .premultiply(qr2.clone().inverse()); + modelBones.Left_arm.quaternion.premultiply(ql.clone().inverse()); + modelBones.Left_elbow.quaternion + .premultiply(ql) + .premultiply(ql2.clone().inverse()); model.updateMatrixWorld(true); for (let i = 0; i < skeleton.bones.length; i++) { From 4156d5c48d875b8be6077b8fa79bcc037912f33a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 03:25:29 -0400 Subject: [PATCH 300/562] Add initial audio volume worklet source --- vrarmik/audio-volume-worklet.js | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 vrarmik/audio-volume-worklet.js diff --git a/vrarmik/audio-volume-worklet.js b/vrarmik/audio-volume-worklet.js new file mode 100644 index 0000000..c223785 --- /dev/null +++ b/vrarmik/audio-volume-worklet.js @@ -0,0 +1,33 @@ +const numTicks = 1; + +let tick = 0; +let sampleSum = 0; +let numSamples = 0; + +class VolumeProcessor extends AudioWorkletProcessor { + process(inputs, outputs) { + const channels = inputs[0]; + // const output = outputs[0]; + + // for (let i = 0; i < channels.length; i++) { + const i = 0; + const samples = channels[i]; + for (let j = 0; j < samples.length; j++) { + sampleSum += Math.abs(samples[j]); + } + numSamples += samples.length; + // } + + if (++tick >= numTicks) { + this.port.postMessage(sampleSum / numSamples); + + tick = 0; + sampleSum = 0; + numSamples = 0; + } + + return true; + } +} + +registerProcessor('volume-processor', VolumeProcessor); \ No newline at end of file From ca7390389046ad308b361afd815101347aef5c18 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 03:26:59 -0400 Subject: [PATCH 301/562] Latch global skinned meshes in Rig.js --- vrarmik/Rig.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 9ff9910..be2fd89 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -57,6 +57,8 @@ class Rig { } }); skinnedMeshes.sort((a, b) => b.skeleton.bones.length - a.skeleton.bones.length); + this.skinnedMeshes = skinnedMeshes; + const skeletonSkinnedMesh = skinnedMeshes.find(o => o.skeleton.bones[0].parent) || null; const skeleton = skeletonSkinnedMesh && skeletonSkinnedMesh.skeleton; if (skeleton) { From 7da9fbaa0f2c596f293bb946c1dd335e973151d0 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 03:27:39 -0400 Subject: [PATCH 302/562] Add commented volume tracking in Rig.js --- vrarmik/Rig.js | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index be2fd89..6fdd63f 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -644,6 +644,24 @@ class Rig { Right_knee: this.outputs.leftLowerLeg, Right_ankle: this.outputs.leftFoot, }; + + /* this.volume = 0; + (async () => { + const mediaStream = await navigator.mediaDevices.getUserMedia({ + audio: true, + }); + + const context = new AudioContext(); + const mediaStreamSource = context.createMediaStreamSource(mediaStream); + + await context.audioWorklet.addModule('vrarmik/audio-volume-worklet.js'); + const audioWorkletNode = new AudioWorkletNode(context, 'volume-processor'); + audioWorkletNode.port.onmessage = e => { + this.volume = this.volume*0.8 + e.data*0.2; + }; + mediaStreamSource.connect(audioWorkletNode).connect(context.destination); + })(); */ + this.lastTimestamp = Date.now(); GameObject.startAll(); From e85344cde347d4a3d4a94a68f0715bd54d5cc059 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 03:27:52 -0400 Subject: [PATCH 303/562] Add commented viseme application in Rig.js --- vrarmik/Rig.js | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 6fdd63f..33851d0 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -810,6 +810,33 @@ class Rig { } }; _processHairBone(this.modelBones.Head, this.hairBones); + + /* const aaValue = Math.min(this.volume * 10, 1); + const blinkValue = (() => { + const nowWindow = now % 2000; + if (nowWindow >= 0 && nowWindow < 100) { + return nowWindow/100; + } else if (nowWindow >= 100 && nowWindow < 200) { + return 1 - (nowWindow-100)/100; + } else { + return 0; + } + })(); + this.skinnedMeshes.forEach(o => { + const {morphTargetDictionary, morphTargetInfluences} = o; + const aaMorphTargetIndex = morphTargetDictionary['vrc.v_aa']; + if (aaMorphTargetIndex !== undefined) { + morphTargetInfluences[aaMorphTargetIndex] = aaValue; + } + const blinkLeftMorphTargetIndex = morphTargetDictionary['vrc.blink_left']; + if (blinkLeftMorphTargetIndex !== undefined) { + morphTargetInfluences[blinkLeftMorphTargetIndex] = blinkValue; + } + const blinkRightMorphTargetIndex = morphTargetDictionary['vrc.blink_right']; + if (blinkRightMorphTargetIndex !== undefined) { + morphTargetInfluences[blinkRightMorphTargetIndex] = blinkValue; + } + }); */ } } export default Rig; \ No newline at end of file From bc51f87ba20aa44fb5ee5cae08673e2000d6900f Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 15:39:52 -0400 Subject: [PATCH 304/562] Accept options in rig --- vrarmik/Rig.js | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 33851d0..fe79a70 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -43,7 +43,10 @@ const _copySkeleton = (src, dst) => { }; class Rig { - constructor(model) { + constructor(model, options = {}) { + this.model = model; + this.options = options; + GameObject.clearAll(); model.updateMatrixWorld(true); From 79c91f50ed094beedd84f7e125e76197e07ead8b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 15:41:56 -0400 Subject: [PATCH 305/562] Use microphone media stream from options --- vrarmik/Rig.js | 30 ++++++++++++++---------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index fe79a70..75b30a6 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -648,22 +648,20 @@ class Rig { Right_ankle: this.outputs.leftFoot, }; - /* this.volume = 0; - (async () => { - const mediaStream = await navigator.mediaDevices.getUserMedia({ - audio: true, - }); - - const context = new AudioContext(); - const mediaStreamSource = context.createMediaStreamSource(mediaStream); - - await context.audioWorklet.addModule('vrarmik/audio-volume-worklet.js'); - const audioWorkletNode = new AudioWorkletNode(context, 'volume-processor'); - audioWorkletNode.port.onmessage = e => { - this.volume = this.volume*0.8 + e.data*0.2; - }; - mediaStreamSource.connect(audioWorkletNode).connect(context.destination); - })(); */ + this.volume = 0; + if (options.microphoneMediaStream) { + (async () => { + const context = new AudioContext(); + const mediaStreamSource = context.createMediaStreamSource(options.microphoneMediaStream); + + await context.audioWorklet.addModule('vrarmik/audio-volume-worklet.js'); + const audioWorkletNode = new AudioWorkletNode(context, 'volume-processor'); + audioWorkletNode.port.onmessage = e => { + this.volume = this.volume*0.8 + e.data*0.2; + }; + mediaStreamSource.connect(audioWorkletNode).connect(context.destination); + })(); + } this.lastTimestamp = Date.now(); From d1613764a249f65579d123304b5ac6703a02cefb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 15:42:26 -0400 Subject: [PATCH 306/562] Respect rig visemes option --- vrarmik/Rig.js | 39 ++++++++++++++++++++++++++------------- 1 file changed, 26 insertions(+), 13 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 75b30a6..4cec88f 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -812,7 +812,7 @@ class Rig { }; _processHairBone(this.modelBones.Head, this.hairBones); - /* const aaValue = Math.min(this.volume * 10, 1); + const aaValue = Math.min(this.volume * 10, 1); const blinkValue = (() => { const nowWindow = now % 2000; if (nowWindow >= 0 && nowWindow < 100) { @@ -825,19 +825,32 @@ class Rig { })(); this.skinnedMeshes.forEach(o => { const {morphTargetDictionary, morphTargetInfluences} = o; - const aaMorphTargetIndex = morphTargetDictionary['vrc.v_aa']; - if (aaMorphTargetIndex !== undefined) { - morphTargetInfluences[aaMorphTargetIndex] = aaValue; - } - const blinkLeftMorphTargetIndex = morphTargetDictionary['vrc.blink_left']; - if (blinkLeftMorphTargetIndex !== undefined) { - morphTargetInfluences[blinkLeftMorphTargetIndex] = blinkValue; - } - const blinkRightMorphTargetIndex = morphTargetDictionary['vrc.blink_right']; - if (blinkRightMorphTargetIndex !== undefined) { - morphTargetInfluences[blinkRightMorphTargetIndex] = blinkValue; + if (morphTargetDictionary && morphTargetInfluences) { + let aaMorphTargetIndex = morphTargetDictionary['vrc.v_aa']; + if (aaMorphTargetIndex === undefined) { + aaMorphTargetIndex = morphTargetDictionary['morphTarget26']; + } + if (aaMorphTargetIndex !== undefined) { + morphTargetInfluences[aaMorphTargetIndex] = aaValue; + } + + let blinkLeftMorphTargetIndex = morphTargetDictionary['vrc.blink_left']; + if (blinkLeftMorphTargetIndex === undefined) { + blinkLeftMorphTargetIndex = morphTargetDictionary['morphTarget16']; + } + if (blinkLeftMorphTargetIndex !== undefined) { + morphTargetInfluences[blinkLeftMorphTargetIndex] = blinkValue; + } + + let blinkRightMorphTargetIndex = morphTargetDictionary['vrc.blink_right']; + if (blinkRightMorphTargetIndex === undefined) { + blinkRightMorphTargetIndex = morphTargetDictionary['morphTarget17']; + } + if (blinkRightMorphTargetIndex !== undefined) { + morphTargetInfluences[blinkRightMorphTargetIndex] = blinkValue; + } } - }); */ + }); } } export default Rig; \ No newline at end of file From d3955b2d2edf8d827db340ba80d3daa195d708d1 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 15:43:23 -0400 Subject: [PATCH 307/562] Respect rig hair option --- vrarmik/Rig.js | 93 ++++++++++++++++++++++++++------------------------ 1 file changed, 49 insertions(+), 44 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 4cec88f..7ee12de 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -383,18 +383,20 @@ class Rig { } return null; }).filter(bone => bone); - hairBones.forEach(rootHairBone => { - rootHairBone.traverse(hairBone => { - hairBone.length = hairBone.position.length(); - hairBone.worldParentOffset = hairBone.getWorldPosition(new Vector3()).sub(hairBone.parent.getWorldPosition(new Vector3())).divide(armatureScale); - hairBone.initialWorldQuaternion = hairBone.getWorldQuaternion(new Quaternion()); - hairBone.velocity = new Vector3(); - if (hairBone !== rootHairBone) { - hairBone._updateMatrixWorld = hairBone.updateMatrixWorld; - hairBone.updateMatrixWorld = () => {}; - } + if (options.hair) { + hairBones.forEach(rootHairBone => { + rootHairBone.traverse(hairBone => { + hairBone.length = hairBone.position.length(); + hairBone.worldParentOffset = hairBone.getWorldPosition(new Vector3()).sub(hairBone.parent.getWorldPosition(new Vector3())).divide(armatureScale); + hairBone.initialWorldQuaternion = hairBone.getWorldQuaternion(new Quaternion()); + hairBone.velocity = new Vector3(); + if (hairBone !== rootHairBone) { + hairBone._updateMatrixWorld = hairBone.updateMatrixWorld; + hairBone.updateMatrixWorld = () => {}; + } + }); }); - }); + } this.hairBones = hairBones; const preRotations = {}; @@ -773,44 +775,47 @@ class Rig { const now = Date.now(); const timeDiff = Math.min(now - this.lastTimestamp, 1000); this.lastTimestamp = now; - const _processHairBone = (hairBone, children) => { - const p = new Vector3().setFromMatrixPosition(hairBone.matrixWorld); - for (let i = 0; i < children.length; i++) { - const childHairBone = children[i]; + if (this.options.hair) { + const _processHairBone = (hairBone, children) => { + const p = new Vector3().setFromMatrixPosition(hairBone.matrixWorld); - const px = new Vector3().setFromMatrixPosition(childHairBone.matrixWorld); - const hairDistance = px.distanceTo(p); - const hairDirection = px.clone().sub(p).normalize(); + for (let i = 0; i < children.length; i++) { + const childHairBone = children[i]; - if (hairDistance > childHairBone.length * 2) { - px.copy(p).add(hairDirection.clone().multiplyScalar(childHairBone.length * 2)); - } + const px = new Vector3().setFromMatrixPosition(childHairBone.matrixWorld); + const hairDistance = px.distanceTo(p); + const hairDirection = px.clone().sub(p).normalize(); - const l = childHairBone.velocity.length(); - if (l > 0.05) { - childHairBone.velocity.multiplyScalar(0.05/l); - } + if (hairDistance > childHairBone.length * 2) { + px.copy(p).add(hairDirection.clone().multiplyScalar(childHairBone.length * 2)); + } - childHairBone.velocity.add(hairDirection.clone().multiplyScalar(-(hairDistance - childHairBone.length) * 0.1 * timeDiff/32)); - childHairBone.velocity.add(new Vector3(0, -9.8, 0).multiplyScalar(0.0002 * timeDiff/32)); - childHairBone.velocity.add(childHairBone.worldParentOffset.clone().applyQuaternion(this.modelBones.Hips.quaternion).multiplyScalar(0.03 * timeDiff/32)); - childHairBone.velocity.lerp(new Vector3(), 0.2 * timeDiff/32); - - const p2 = px.clone().add(childHairBone.velocity.clone().multiplyScalar(1)); - const q2 = childHairBone.initialWorldQuaternion.clone().premultiply( - new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( - new Vector3(0, 0, 0), - hairDirection, - new Vector3(0, 0, -1).applyQuaternion(this.modelBones.Hips.quaternion), - )) - ); - const s2 = new Vector3(1, 1, 1); - childHairBone.matrixWorld.compose(p2, q2, s2); - _processHairBone(childHairBone, childHairBone.children); - } - }; - _processHairBone(this.modelBones.Head, this.hairBones); + const l = childHairBone.velocity.length(); + if (l > 0.05) { + childHairBone.velocity.multiplyScalar(0.05/l); + } + + childHairBone.velocity.add(hairDirection.clone().multiplyScalar(-(hairDistance - childHairBone.length) * 0.1 * timeDiff/32)); + childHairBone.velocity.add(new Vector3(0, -9.8, 0).multiplyScalar(0.0002 * timeDiff/32)); + childHairBone.velocity.add(childHairBone.worldParentOffset.clone().applyQuaternion(this.modelBones.Hips.quaternion).multiplyScalar(0.03 * timeDiff/32)); + childHairBone.velocity.lerp(new Vector3(), 0.2 * timeDiff/32); + + const p2 = px.clone().add(childHairBone.velocity.clone().multiplyScalar(1)); + const q2 = childHairBone.initialWorldQuaternion.clone().premultiply( + new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( + new Vector3(0, 0, 0), + hairDirection, + new Vector3(0, 0, -1).applyQuaternion(this.modelBones.Hips.quaternion), + )) + ); + const s2 = new Vector3(1, 1, 1); + childHairBone.matrixWorld.compose(p2, q2, s2); + _processHairBone(childHairBone, childHairBone.children); + } + }; + _processHairBone(this.modelBones.Head, this.hairBones); + } const aaValue = Math.min(this.volume * 10, 1); const blinkValue = (() => { From 9ff5c87395c41995d1c77a4e9658787d0e933b33 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 15:43:39 -0400 Subject: [PATCH 308/562] Respect rig visemes option --- vrarmik/Rig.js | 72 ++++++++++++++++++++++++++------------------------ 1 file changed, 37 insertions(+), 35 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 7ee12de..26328ee 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -817,45 +817,47 @@ class Rig { _processHairBone(this.modelBones.Head, this.hairBones); } - const aaValue = Math.min(this.volume * 10, 1); - const blinkValue = (() => { - const nowWindow = now % 2000; - if (nowWindow >= 0 && nowWindow < 100) { - return nowWindow/100; - } else if (nowWindow >= 100 && nowWindow < 200) { - return 1 - (nowWindow-100)/100; - } else { - return 0; - } - })(); - this.skinnedMeshes.forEach(o => { - const {morphTargetDictionary, morphTargetInfluences} = o; - if (morphTargetDictionary && morphTargetInfluences) { - let aaMorphTargetIndex = morphTargetDictionary['vrc.v_aa']; - if (aaMorphTargetIndex === undefined) { - aaMorphTargetIndex = morphTargetDictionary['morphTarget26']; - } - if (aaMorphTargetIndex !== undefined) { - morphTargetInfluences[aaMorphTargetIndex] = aaValue; + if (this.options.visemes) { + const aaValue = Math.min(this.volume * 10, 1); + const blinkValue = (() => { + const nowWindow = now % 2000; + if (nowWindow >= 0 && nowWindow < 100) { + return nowWindow/100; + } else if (nowWindow >= 100 && nowWindow < 200) { + return 1 - (nowWindow-100)/100; + } else { + return 0; } + })(); + this.skinnedMeshes.forEach(o => { + const {morphTargetDictionary, morphTargetInfluences} = o; + if (morphTargetDictionary && morphTargetInfluences) { + let aaMorphTargetIndex = morphTargetDictionary['vrc.v_aa']; + if (aaMorphTargetIndex === undefined) { + aaMorphTargetIndex = morphTargetDictionary['morphTarget26']; + } + if (aaMorphTargetIndex !== undefined) { + morphTargetInfluences[aaMorphTargetIndex] = aaValue; + } - let blinkLeftMorphTargetIndex = morphTargetDictionary['vrc.blink_left']; - if (blinkLeftMorphTargetIndex === undefined) { - blinkLeftMorphTargetIndex = morphTargetDictionary['morphTarget16']; - } - if (blinkLeftMorphTargetIndex !== undefined) { - morphTargetInfluences[blinkLeftMorphTargetIndex] = blinkValue; - } + let blinkLeftMorphTargetIndex = morphTargetDictionary['vrc.blink_left']; + if (blinkLeftMorphTargetIndex === undefined) { + blinkLeftMorphTargetIndex = morphTargetDictionary['morphTarget16']; + } + if (blinkLeftMorphTargetIndex !== undefined) { + morphTargetInfluences[blinkLeftMorphTargetIndex] = blinkValue; + } - let blinkRightMorphTargetIndex = morphTargetDictionary['vrc.blink_right']; - if (blinkRightMorphTargetIndex === undefined) { - blinkRightMorphTargetIndex = morphTargetDictionary['morphTarget17']; - } - if (blinkRightMorphTargetIndex !== undefined) { - morphTargetInfluences[blinkRightMorphTargetIndex] = blinkValue; + let blinkRightMorphTargetIndex = morphTargetDictionary['vrc.blink_right']; + if (blinkRightMorphTargetIndex === undefined) { + blinkRightMorphTargetIndex = morphTargetDictionary['morphTarget17']; + } + if (blinkRightMorphTargetIndex !== undefined) { + morphTargetInfluences[blinkRightMorphTargetIndex] = blinkValue; + } } - } - }); + }); + } } } export default Rig; \ No newline at end of file From 54076d98c26f8f373789b4579492d819bb49b801 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 15:44:42 -0400 Subject: [PATCH 309/562] Add initial vrarmik.html multibutton --- vrarmik.html | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 52625bd..bcffaaf 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -67,7 +67,7 @@ padding-top: 50px; background-color: #FFF; } -h1, h2, h3, h4, h5, h6, p { +h1, h2, h3, h4, h5, h6, p, .examples > .multibutton { margin: 20px 0; padding: 0 20px; font-weight: inherit; @@ -126,26 +126,34 @@ a:active { color: #1976d2; } -.body > .buttons { +.body > .multibutton { position: absolute; right: 30px; bottom: 30px; } -.buttons { +.multibutton { display: flex; - margin: 5px 20px; +} +.multibutton .button:not(.first) { + border-top-left-radius: 0; + border-bottom-left-radius: 0; +} +.multibutton .button:not(.last) { + border-top-right-radius: 0; + border-bottom-right-radius: 0; } .button { display: inline-flex; + margin-right: 5px; padding: 8px 20px; border: 2px solid; border-radius: 100px; color: #5c6bc0; cursor: pointer; } -.button:not(:last-child) { +/* .button:not(:last-child) { margin-right: 20px; -} +} */ .button:not([disabled]):hover { background-color: #5c6bc0; border-color: #5c6bc0; @@ -232,9 +240,9 @@

Examples

model4.zip
model5.fbx

-
+
@@ -242,9 +250,11 @@

Examples

-
- - +
+ + + +
From 4e493bac2f0a73bef532defd4a1a1ceb27f893c1 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 15:49:51 -0400 Subject: [PATCH 312/562] Use mesh dolly for avatar and bone helper meshes --- vrarmik.html | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index e7355ab..18370c6 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -690,12 +690,12 @@

Examples

mesh.onBeforeRender2 = () => { if (model && session) { - model.visible = true; + meshDolly.visible = true; } }; mesh.onAfterRender2 = () => { if (model && session) { - model.visible = false; + meshDolly.visible = false; } }; @@ -712,21 +712,21 @@

Examples

let heightFactor = 0; const _rigModel = object => { if (rig) { - scene.remove(model); + meshDolly.remove(model); rig = null; model = null; } model = object; if (session) { - model.visible = false; + meshDolly.visible = false; } rig = new Rig(model, { hair: true, visemes: true, microphoneMediaStream, }); - scene.add(model); + meshDolly.add(model); window.model = model; // heightOffset = userHeight - rig.height; @@ -913,7 +913,7 @@

Examples

requiredFeatures: ['local-floor'], }); if (model) { - model.visible = false; + meshDolly.visible = false; } let referenceSpace; let referenceSpaceType = ''; From 5a0e911c1bd956a600ac95fee69e1114a649a56a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 16:29:49 -0400 Subject: [PATCH 313/562] Small mesh dolly dead code cleanup --- vrarmik.html | 3 --- 1 file changed, 3 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 18370c6..635906e 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -718,9 +718,6 @@

Examples

} model = object; - if (session) { - meshDolly.visible = false; - } rig = new Rig(model, { hair: true, visemes: true, From e014cf96037a0a284bf75095af2b0113ad306670 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 18:41:15 -0400 Subject: [PATCH 314/562] Major Unity emulation structure update --- vrarmik/Unity.js | 94 +++++++++++++++++++++++++++++------------------- 1 file changed, 57 insertions(+), 37 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index a49ea83..42c6140 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -339,8 +339,13 @@ class Transform { const gameObjects = []; class GameObject { - constructor(name) { + constructor(name, unity) { + if (!unity) { + throw new Error('bad game object initialization'); + } + this.name = name; + this.unity = unity; this.transform = new Transform(); this.components = new Map(); @@ -350,7 +355,7 @@ class GameObject { AddComponent(Constructor) { let component = this.components.get(Constructor); if (component === undefined) { - component = new Constructor(this.transform, this.components); + component = new Constructor(this.transform, this.components, this.unity); this.components.set(Constructor, component); } return component; @@ -358,54 +363,23 @@ class GameObject { AddChild(child) { this.transform.AddChild(child.transform); } - static clearAll() { - gameObjects.length = 0; - } - static startAll() { - for (let i = 0; i < gameObjects.length; i++) { - gameObjects[i].components.forEach(value => { - value.Awake(); - }); - } - for (let i = 0; i < gameObjects.length; i++) { - gameObjects[i].components.forEach(value => { - value.OnEnable(); - }); - } - for (let i = 0; i < gameObjects.length; i++) { - gameObjects[i].components.forEach(value => { - value.Start(); - }); - } - } - static updateAll() { - for (let i = 0; i < gameObjects.length; i++) { - gameObjects[i].components.forEach(value => { - value.Update(); - }); - } - for (let i = 0; i < gameObjects.length; i++) { - gameObjects[i].components.forEach(value => { - value.LateUpdate(); - }); - } - } } class MonoBehavior { - constructor(transform, components) { - if (!transform || !components) { + constructor(transform, components, unity) { + if (!transform || !components || !unity) { throw new Error('bad component initialization'); } this.transform = transform; this.components = components; + this.unity = unity; } GetComponent(Constructor) { let component = this.components.get(Constructor); if (component === undefined) { - component = new Constructor(this.transform, this.components); + component = new Constructor(this.transform, this.components, this.unity); this.components.set(Constructor, component); } return component; @@ -513,6 +487,51 @@ const XRSettings = { loadedDeviceName: 'OpenVR', }; +class Unity { + constructor() { + this.gameObjects = []; + } + + makeGameObject(name) { + const gameObject = new GameObject(name, this); + this.gameObjects.push(gameObject); + return gameObject; + } + + clearAll() { + this.gameObjects.length = 0; + } + startAll() { + for (let i = 0; i < this.gameObjects.length; i++) { + this.gameObjects[i].components.forEach(value => { + value.Awake(); + }); + } + for (let i = 0; i < this.gameObjects.length; i++) { + this.gameObjects[i].components.forEach(value => { + value.OnEnable(); + }); + } + for (let i = 0; i < this.gameObjects.length; i++) { + this.gameObjects[i].components.forEach(value => { + value.Start(); + }); + } + } + updateAll() { + for (let i = 0; i < this.gameObjects.length; i++) { + this.gameObjects[i].components.forEach(value => { + value.Update(); + }); + } + for (let i = 0; i < this.gameObjects.length; i++) { + this.gameObjects[i].components.forEach(value => { + value.LateUpdate(); + }); + } + } +} + export { Vector2, Vector3, @@ -524,4 +543,5 @@ export { Mathf, PlayerPrefs, XRSettings, + Unity, }; From 93773549d1c1e4ce195b7ec203f9fe169657a702 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 18:43:29 -0400 Subject: [PATCH 315/562] Hook in new Unity local engine API --- vrarmik/AvatarVRTrackingReferences.js | 10 ++++++---- vrarmik/LegsManager.js | 8 ++++---- vrarmik/PoseManager.js | 9 +++++---- vrarmik/Rig.js | 11 ++++++----- vrarmik/ShoulderTransforms.js | 8 ++++---- 5 files changed, 25 insertions(+), 21 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 5790226..93d9c82 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -5,13 +5,15 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; class AvatarVRTrackingReferences extends MonoBehavior { - constructor(...args) { - super(...args); + constructor(transform, components, unity) { + super(transform, components, unity); this.head = null; // this.hmd = null; this.leftHand = null; this.rightHand = null; + + this.unity = unity; } Awake() @@ -42,7 +44,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; let t = this[k]; if (t === null) { - t = new GameObject(name).AddComponent(StaticOffsetTransform); + t = this.unity.makeGameObject(name).AddComponent(StaticOffsetTransform); this.transform.AddChild(t.transform); this.setStaticOffsetSettings(t); this[k] = t; @@ -53,7 +55,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; { if (t === null) { - t = new GameObject(name).transform; + t = this.unity.makeGameObject(name).transform; t.transform.localPosition = Vector3.zero; this.transform.AddChild(t.transform); } diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index dff36d8..3c055fe 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -174,14 +174,14 @@ class Leg extends MonoBehavior { class LegsManager extends MonoBehavior { - constructor(...args) { - super(...args); + constructor(transform, components, unity) { + super(transform, components, unity); const shoulderTransforms = this.GetOrAddComponent(ShoulderTransforms); this.hips = shoulderTransforms.hips; - this.leftLeg = new GameObject().AddComponent(Leg); + this.leftLeg = unity.makeGameObject().AddComponent(Leg); this.hips.AddChild(this.leftLeg.transform); - this.rightLeg = new GameObject().AddComponent(Leg); + this.rightLeg = unity.makeGameObject().AddComponent(Leg); this.hips.AddChild(this.rightLeg.transform); this.rightLeg.foot.stickTransform.position = this.rightLeg.foot.position; diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 5e502c1..4c6ccda 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -4,11 +4,12 @@ import {GameObject, MonoBehavior, XRSettings} from './Unity.js'; class PoseManager extends MonoBehavior { - constructor(...args) { - super(...args); + constructor(transform, components, unity) { + super(transform, components, unity); - this.vrTransforms = new GameObject().AddComponent(VRTrackingReferences); - this.avatarVrTransforms = new GameObject().AddComponent(AvatarVRTrackingReferences); + this.vrTransforms = unity.makeGameObject().AddComponent(VRTrackingReferences); + this.avatarVrTransforms = unity.makeGameObject().AddComponent(AvatarVRTrackingReferences); + this.avatarVrTransforms.poseManager = this; // this.OnCalibrateListener = null; // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 26328ee..b44bfec 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion, GameObject} from './Unity.js'; +import {Vector3, Quaternion, Unity} from './Unity.js'; import {fixSkeletonZForward} from '../proto/three-ik/modified.AxisUtils.js'; import PoseManager from './PoseManager.js'; import ShoulderTransforms from './ShoulderTransforms.js'; @@ -47,7 +47,8 @@ class Rig { this.model = model; this.options = options; - GameObject.clearAll(); + const unity = new Unity(); + this.unity = unity; model.updateMatrixWorld(true); const skinnedMeshes = []; @@ -564,7 +565,7 @@ class Rig { rightFoot: _getOffset(modelBones.Left_ankle), }; - const rigObject = new GameObject('rig'); + const rigObject = this.unity.makeGameObject('rig'); this.poseManager = rigObject.AddComponent(PoseManager); this.poseManager.flipY = flipY; this.shoulderTransforms = rigObject.AddComponent(ShoulderTransforms); @@ -667,11 +668,11 @@ class Rig { this.lastTimestamp = Date.now(); - GameObject.startAll(); + unity.startAll(); } update() { // return; - GameObject.updateAll(); + this.unity.updateAll(); for (const k in this.modelBones) { const modelBone = this.modelBones[k]; diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 959f321..38d2388 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -7,8 +7,8 @@ import PoseManager from './PoseManager.js'; class ShoulderTransforms extends MonoBehavior { - constructor(...args) { - super(...args); + constructor(transform, components, unity) { + super(transform, components, unity); this.hips = new Transform(); this.spine = new Transform(); @@ -34,8 +34,8 @@ class ShoulderTransforms extends MonoBehavior this.rightShoulderAnchor = new Transform(); this.transform.AddChild(this.rightShoulderAnchor); - this.leftArm = new GameObject().AddComponent(ArmTransforms); - this.rightArm = new GameObject().AddComponent(ArmTransforms); + this.leftArm = unity.makeGameObject().AddComponent(ArmTransforms); + this.rightArm = unity.makeGameObject().AddComponent(ArmTransforms); this.leftShoulderAnchor.AddChild(this.leftArm.transform); this.rightShoulderAnchor.AddChild(this.rightArm.transform); From d906abf6e7e5ed5ae4efce139d516796b463ee90 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 18:47:15 -0400 Subject: [PATCH 316/562] Make PoseManager an instance --- vrarmik/ArmTransforms.js | 4 +++- vrarmik/AvatarVRTrackingReferences.js | 9 +++++---- vrarmik/PoseManager.js | 4 ++-- vrarmik/ShoulderPoser.js | 9 +++++---- vrarmik/ShoulderTransforms.js | 3 +++ 5 files changed, 18 insertions(+), 11 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 65229eb..b900c78 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -21,6 +21,8 @@ class ArmTransforms extends MonoBehavior this.armLengthByScale = false; this.scaleAxis = Vector3.one; this.scaleHandFactor = .7; + + this.poseManager = null; } get upperArmLength() { @@ -51,7 +53,7 @@ class ArmTransforms extends MonoBehavior updateArmLengths() { const shoulderWidth = new Vector3().subVectors(this.upperArm.position, this.lowerArm.position).magnitude; - const _armLength = (PoseManager.Instance.playerWidthWrist - shoulderWidth) / 2; + const _armLength = (this.poseManager.playerWidthWrist - shoulderWidth) / 2; this.setArmLength(_armLength); } diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 93d9c82..2e731bf 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -14,6 +14,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; this.rightHand = null; this.unity = unity; + this.poseManager = null; } Awake() @@ -77,10 +78,10 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; sot.reference = this.transform.parent; } */ - this.head.reference = this.head.reference !== null ? this.head.reference : PoseManager.Instance.vrTransforms.head; - // this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : PoseManager.Instance.vrTransforms.hmd; - this.leftHand.reference = this.leftHand.reference !== null ? this.leftHand.reference : PoseManager.Instance.vrTransforms.leftHand; - this.rightHand.reference = this.rightHand.reference !== null ? this.rightHand.reference : PoseManager.Instance.vrTransforms.rightHand; + this.head.reference = this.head.reference !== null ? this.head.reference : this.poseManager.vrTransforms.head; + // this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : this.poseManager.vrTransforms.hmd; + this.leftHand.reference = this.leftHand.reference !== null ? this.leftHand.reference : this.poseManager.vrTransforms.leftHand; + this.rightHand.reference = this.rightHand.reference !== null ? this.rightHand.reference : this.poseManager.vrTransforms.rightHand; } } diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 4c6ccda..455dc51 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -25,7 +25,7 @@ class PoseManager extends MonoBehavior this.flipY = false; - PoseManager.Instance = this; + // PoseManager.Instance = this; } /* OnEnable() @@ -91,6 +91,6 @@ class PoseManager extends MonoBehavior this.playerWidthWrist = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthWrist", this.referencePlayerWidthWrist); } } - PoseManager.Instance = null; + // PoseManager.Instance = null; export default PoseManager; diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index d221fc0..e8fcb04 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -54,10 +54,11 @@ class ShoulderPoser extends MonoBehavior this.leftShoulderAnkerStartLocalPosition = new Vector3(); this.rightShoulderAnkerStartLocalPosition = new Vector3(); + this.poseManager = this.GetOrAddComponent(PoseManager); if (this.vrTrackingReferences === null) - this.vrTrackingReferences = PoseManager.Instance.vrTransforms; + this.vrTrackingReferences = this.poseManager.vrTransforms; if (this.avatarTrackingReferences === null) - this.avatarTrackingReferences = PoseManager.Instance.avatarVrTransforms; + this.avatarTrackingReferences = this.poseManager.avatarVrTransforms; } Start() { @@ -210,8 +211,8 @@ class ShoulderPoser extends MonoBehavior rotateShoulderRightBase() { - const heightDiff = this.vrTrackingReferences.head.position.y - PoseManager.Instance.vrSystemOffsetHeight; - const relativeHeightDiff = -heightDiff / PoseManager.Instance.playerHeightHmd; + const heightDiff = this.vrTrackingReferences.head.position.y - this.poseManager.vrSystemOffsetHeight; + const relativeHeightDiff = -heightDiff / this.poseManager.playerHeightHmd; const hmdRotation = this.vrTrackingReferences.head.rotation; hmdRotation.multiply(z180Quaternion); diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 38d2388..4200ef2 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -34,8 +34,11 @@ class ShoulderTransforms extends MonoBehavior this.rightShoulderAnchor = new Transform(); this.transform.AddChild(this.rightShoulderAnchor); + const poseManager = this.GetOrAddComponent(PoseManager); this.leftArm = unity.makeGameObject().AddComponent(ArmTransforms); + this.leftArm.poseManager = poseManager; this.rightArm = unity.makeGameObject().AddComponent(ArmTransforms); + this.rightArm.poseManager = poseManager; this.leftShoulderAnchor.AddChild(this.leftArm.transform); this.rightShoulderAnchor.AddChild(this.rightArm.transform); From f191555d0d90e5ef8926ce92f207fa91d502f184 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 18:55:55 -0400 Subject: [PATCH 317/562] Small dead code cleanup --- vrarmik/VRArmIK.js | 1 - 1 file changed, 1 deletion(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index ad82dca..f1d429f 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,6 +1,5 @@ import {Vector3, Quaternion, Transform, GameObject, MonoBehavior, Time, Mathf} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; -import ShoulderTransforms from './ShoulderTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; import VectorHelpers from './Utils/VectorHelpers.js'; import PoseManager from './PoseManager.js'; From e45c7e33742936ec0da7974ee65d183b6946cec7 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Sun, 27 Oct 2019 18:56:07 -0400 Subject: [PATCH 318/562] More dead code cleanup --- vrarmik/LegsManager.js | 2 -- 1 file changed, 2 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 3c055fe..a21c1b2 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -187,8 +187,6 @@ class LegsManager extends MonoBehavior this.rightLeg.foot.stickTransform.position = this.rightLeg.foot.position; this.rightLeg.left = false; - // this.spineLength = 0.3525347660851869; - this.poseManager = this.GetOrAddComponent(PoseManager); this.leftLeg.poseManager = this.poseManager; this.rightLeg.poseManager = this.poseManager; From 1a07217f09d02efb167ffa2103f5a87de961e593 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 00:31:39 -0400 Subject: [PATCH 319/562] Add multiplayer.js --- multiplayer.js | 290 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 290 insertions(+) create mode 100644 multiplayer.js diff --git a/multiplayer.js b/multiplayer.js new file mode 100644 index 0000000..eab5403 --- /dev/null +++ b/multiplayer.js @@ -0,0 +1,290 @@ +const defaultIceServers = [ + {'urls': 'stun:stun.stunprotocol.org:3478'}, + {'urls': 'stun:stun.l.google.com:19302'}, +]; + +function _randomString() { + return Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5); +} + +class XRChannelConnection extends EventTarget { + constructor(url) { + super(); + + this.rtcWs = new WebSocket(url); + this.connectionId = _randomString(); + this.peerConnections = []; + + this.rtcWs.onopen = () => { + // console.log('presence socket open'); + + this.rtcWs.send(JSON.stringify({ + method: 'init', + connectionId: this.connectionId, + })); + }; + const _addPeerConnection = peerConnectionId => { + let peerConnection = this.peerConnections.find(peerConnection => peerConnection.connectionId === peerConnectionId); + if (peerConnection && !peerConnection.open) { + peerConnection.close(); + peerConnection = null; + } + if (!peerConnection) { + peerConnection = new XRPeerConnection(peerConnectionId); + this.dispatchEvent(new CustomEvent('peerconnection', { + detail: peerConnection, + })); + peerConnection.addEventListener('close', () => { + const index = this.peerConnections.indexOf(peerConnection); + if (index !== -1) { + this.peerConnections.splice(index, 1); + } + }); + peerConnection.peerConnection.onicecandidate = e => { + // console.log('ice candidate', e.candidate); + + this.rtcWs.send(JSON.stringify({ + dst: peerConnectionId, + src: this.connectionId, + method: 'iceCandidate', + candidate: e.candidate, + })); + }; + this.peerConnections.push(peerConnection); + + if (this.connectionId < peerConnectionId) { + peerConnection.peerConnection + .createOffer() + .then(offer => { + peerConnection.peerConnection.setLocalDescription(offer); + + this.rtcWs.send(JSON.stringify({ + dst: peerConnectionId, + src: this.connectionId, + method: 'offer', + offer, + })); + }); + } + } + }; + const _removePeerConnection = peerConnectionId => { + const index = this.peerConnections.findIndex(peerConnection => peerConnection.connectionId === peerConnectionId); + if (index !== -1) { + this.peerConnections.splice(index, 1)[0].close(); + } else { + console.warn('no such peer connection', peerConnectionId, this.peerConnections.map(peerConnection => peerConnection.connectionId)); + } + }; + this.rtcWs.onmessage = e => { + // console.log('got message', e.data); + + const data = JSON.parse(e.data); + const {method} = data; + if (method === 'join') { + const {connectionId: peerConnectionId} = data; + _addPeerConnection(peerConnectionId); + } else if (method === 'offer') { + const {src: peerConnectionId, offer} = data; + + const peerConnection = this.peerConnections.find(peerConnection => peerConnection.connectionId === peerConnectionId); + if (peerConnection) { + peerConnection.peerConnection.setRemoteDescription(offer) + .then(() => peerConnection.peerConnection.createAnswer()) + .then(answer => { + peerConnection.peerConnection.setLocalDescription(answer); + + this.rtcWs.send(JSON.stringify({ + dst: peerConnectionId, + src: this.connectionId, + method: 'answer', + answer, + })); + }); + } else { + console.warn('no such peer connection', peerConnectionId, this.peerConnections.map(peerConnection => peerConnection.connectionId)); + } + } else if (method === 'answer') { + const {src: peerConnectionId, answer} = data; + + const peerConnection = this.peerConnections.find(peerConnection => peerConnection.connectionId === peerConnectionId); + if (peerConnection) { + peerConnection.peerConnection.setRemoteDescription(answer); + } else { + console.warn('no such peer connection', peerConnectionId, this.peerConnections.map(peerConnection => peerConnection.connectionId)); + } + } else if (method === 'iceCandidate') { + const {src: peerConnectionId, candidate} = data; + + const peerConnection = this.peerConnections.find(peerConnection => peerConnection.connectionId === peerConnectionId); + if (peerConnection) { + peerConnection.peerConnection.addIceCandidate(candidate) + .catch(err => { + // console.warn(err); + }); + } else { + console.warn('no such peer connection', peerConnectionId, this.peerConnections.map(peerConnection => peerConnection.connectionId)); + } + } else if (method === 'leave') { + const {connectionId: peerConnectionId} = data; + _removePeerConnection(peerConnectionId); + } else { + this.dispatchEvent(new MessageEvent('message', { + data: e.data, + })); + } + }; + this.rtcWs.onclose = () => { + clearInterval(pingInterval); + console.log('rtc closed'); + }; + this.rtcWs.onerror = err => { + console.warn('rtc error', err); + clearInterval(pingInterval); + }; + const pingInterval = setInterval(() => { + this.rtcWs.send(JSON.stringify({ + method: 'ping', + })); + }, 30*1000); + } + + disconect() { + this.rtcWs.close(); + this.rtcWs = null; + + for (let i = 0; i < this.peerConnections[i]; i++) { + this.peerConnections[i].close(); + } + this.peerConnections.length = 0; + } + + send(s) { + this.rtcWs.send(s); + } + + update(hmd, gamepads) { + for (let i = 0; i < this.peerConnections.length; i++) { + const peerConnection = this.peerConnections[i]; + if (peerConnection.open) { + peerConnection.update(hmd, gamepads); + } + } + } +} +window.XRChannelConnection = XRChannelConnection; + +class XRPeerConnection extends EventTarget { + constructor(peerConnectionId) { + super(); + + this.connectionId = peerConnectionId; + + this.peerConnection = new RTCPeerConnection({ + iceServers: defaultIceServers, + }); + this.open = false; + + this.peerConnection.ontrack = e => { + console.log('got track', e); + }; + + const sendChannel = this.peerConnection.createDataChannel('sendChannel'); + this.peerConnection.sendChannel = sendChannel; + let pingInterval = 0; + sendChannel.onopen = () => { + // console.log('data channel local open'); + + this.open = true; + this.dispatchEvent(new CustomEvent('open')); + + pingInterval = setInterval(() => { + sendChannel.send(JSON.stringify({ + method: 'ping', + })); + }, 1000); + }; + sendChannel.onclose = () => { + // console.log('data channel local close'); + + _cleanup(); + }; + sendChannel.onerror = err => { + // console.log('data channel local error', err); + }; + let watchdogTimeout = 0; + const _kick = () => { + if (watchdogTimeout) { + clearTimeout(watchdogTimeout); + watchdogTimeout = 0; + } + watchdogTimeout = setTimeout(() => { + this.peerConnection.close(); + }, 5000); + }; + _kick(); + this.peerConnection.ondatachannel = e => { + const {channel} = e; + // console.log('data channel remote open', channel); + channel.onclose = () => { + // console.log('data channel remote close'); + this.peerConnection.close(); + }; + channel.onerror = err => { + // console.log('data channel remote error', err); + }; + channel.onmessage = e => { + // console.log('data channel message', e.data); + + const data = JSON.parse(e.data); + const {method} = data; + if (method === 'pose') { + this.dispatchEvent(new CustomEvent('pose', { + detail: data, + })) + } else if (method === 'ping') { + // nothing + } else { + this.dispatchEvent(new MessageEvent('message', { + data, + })); + } + + _kick(); + }; + this.peerConnection.recvChannel = channel; + }; + this.peerConnection.close = (close => function() { + _cleanup(); + + return close.apply(this, arguments); + })(this.peerConnection.close); + const _cleanup = () => { + if (this.open) { + this.open = false; + this.dispatchEvent(new CustomEvent('close')); + } + if (pingInterval) { + clearInterval(pingInterval); + pingInterval = 0; + } + }; + } + + close() { + this.peerConnection.close(); + } + + send(s) { + this.peerConnection.sendChannel.send(s); + } + + update(hmd, gamepads) { + this.send(JSON.stringify({ + method: 'pose', + hmd, + gamepads, + })); + } +} +window.XRPeerConnection = XRPeerConnection; \ No newline at end of file From 666ea4c587f45db993c3be6a6dbc6ff9bda939b4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 01:12:13 -0400 Subject: [PATCH 320/562] Add multiplayer.js open/close/error events dispatch --- multiplayer.js | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/multiplayer.js b/multiplayer.js index eab5403..7a2b3ca 100644 --- a/multiplayer.js +++ b/multiplayer.js @@ -22,6 +22,8 @@ class XRChannelConnection extends EventTarget { method: 'init', connectionId: this.connectionId, })); + + this.dispatchEvent(new CustomEvent('open')); }; const _addPeerConnection = peerConnectionId => { let peerConnection = this.peerConnections.find(peerConnection => peerConnection.connectionId === peerConnectionId); @@ -137,10 +139,16 @@ class XRChannelConnection extends EventTarget { this.rtcWs.onclose = () => { clearInterval(pingInterval); console.log('rtc closed'); + + this.dispatchEvent(new CustomEvent('close')); }; this.rtcWs.onerror = err => { console.warn('rtc error', err); clearInterval(pingInterval); + + this.dispatchEvent(new ErrorEvent('error', { + message: err.stack, + })); }; const pingInterval = setInterval(() => { this.rtcWs.send(JSON.stringify({ From 7f0f25ff33dcaf3402789b3e6e4981b029163373 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 02:29:32 -0400 Subject: [PATCH 321/562] Add initial multiplayer connect button --- vrarmik.html | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/vrarmik.html b/vrarmik.html index 635906e..3e7d066 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -204,6 +204,17 @@ } .code:not(.open) { display: none; +} +input[type=text] { + width: 160px; + margin: 0 20px; + padding: 7px 15px; + background-color: #f2f3f5; + border: 0; + border-radius: 8px; + font-family: inherit; + font-size: inherit; + outline: none; } @@ -246,6 +257,11 @@

Examples

+

Multiplayer

+ +
+ +
From 96f6d3fef716bf6a7667f88a95174499b1c9a1fc Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 03:15:32 -0400 Subject: [PATCH 322/562] Small multiplayer.js bugfix --- multiplayer.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multiplayer.js b/multiplayer.js index 7a2b3ca..74da2b2 100644 --- a/multiplayer.js +++ b/multiplayer.js @@ -254,7 +254,7 @@ class XRPeerConnection extends EventTarget { // nothing } else { this.dispatchEvent(new MessageEvent('message', { - data, + data: e.data, })); } From 99f6fa7f6663ca0ee8ebfd81e61ea7712e1cb113 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 03:17:06 -0400 Subject: [PATCH 323/562] Major model loading refactoring --- vrarmik.html | 121 +++++++++++++++++++++++++++------------------------ 1 file changed, 65 insertions(+), 56 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 3e7d066..21a3102 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -422,7 +422,7 @@

Multiplayer

const match = pathname.match(/([^\/]+)$/); return match && match[1]; }; -const _loadModelFilesystem = filesystem => { +const _loadModelFilesystem = async filesystem => { const manager = new THREE.LoadingManager(); manager.setURLModifier(url => { // console.log('load url', url); @@ -459,17 +459,17 @@

Multiplayer

const modelFileUrl = modelFile.url; console.log(`using model file: ${modelFile.pathname}`); if (/\.fbx$/.test(modelFile.pathname)) { - new THREE.FBXLoader(manager).load(modelFileUrl, object => { - _rigModel(object); - }, function onprogress() {}, function onerror(err) { - console.warn(err); + const model = await new Promise((accept, reject) => { + new THREE.FBXLoader(manager).load(modelFileUrl, accept, function onprogress() {}, reject); }); + return model; } else { - new THREE.GLTFLoader(manager).load(modelFileUrl, object => { - _rigModel(object.scene); - }, xhr => {}, err => { - console.warn(err); + const model = await new Promise((accept, reject) => { + new THREE.GLTFLoader(manager).load(modelFileUrl, object => { + accept(object.scene); + }, xhr => {}, reject); }); + return model; } } else { throw new Error('no model file in package'); @@ -486,53 +486,51 @@

Multiplayer

const _loadModelUrl = async (href, filename = href) => { const fileType = _getFileType(filename); if (fileType === 'gltf') { - new THREE.GLTFLoader().load(href, object => { - _rigModel(object.scene); - }, xhr => {}, err => { - console.warn(err); + const model = await new Promise((accept, reject) => { + new THREE.GLTFLoader().load(href, object => { + accept(object.scene); + }, xhr => {}, reject); }); + return model; } else if (fileType === 'fbx') { - new THREE.FBXLoader().load(href, object => { - _rigModel(object); - }, xhr => {}, err => { - console.warn(err); + const model = await new Promise((accept, reject) => { + new THREE.FBXLoader().load(href, accept, xhr => {}, reject); }); + return model; } else if (fileType === 'zip') { const unitypackageRes = await fetch(href); const blob = await unitypackageRes.blob(); - zip.createReader(new zip.BlobReader(blob), function(reader) { - reader.getEntries(async function(entries) { - const filesystem = []; - for (let i = 0; i < entries.length; i++) { - const entry = entries[i]; - const pathname = entry.filename; - const filename = _pathname2Filename(pathname); - const blob = await new Promise((accept, reject) => { - entry.getData(new zip.BlobWriter('application/octet-stream'), function(blob) { - accept(blob); - }, function(current, total) { - // onprogress callback - }); - }); - const url = URL.createObjectURL(blob); - filesystem.push({ - pathname, - filename, - url, - }); - // console.log('got blob', entry, blob, pathname, filename, url); - } - // console.log('got filesystem', filesystem); - _loadModelFilesystem(filesystem); + const reader = await new Promise((accept, reject) => { + zip.createReader(new zip.BlobReader(blob), accept, reject); + }); + const entries = await new Promise((accept, reject) => { + reader.getEntries(accept); + }); - /* // close the zip reader - reader.close(function() { - // onclose callback - }); */ + const filesystem = []; + for (let i = 0; i < entries.length; i++) { + const entry = entries[i]; + const pathname = entry.filename; + const filename = _pathname2Filename(pathname); + const blob = await new Promise((accept, reject) => { + entry.getData(new zip.BlobWriter('application/octet-stream'), function(blob) { + accept(blob); + }, function(current, total) { + // onprogress callback + }); }); - }, function(err) { - console.warn(err); - }); + const url = URL.createObjectURL(blob); + filesystem.push({ + pathname, + filename, + url, + }); + // console.log('got blob', entry, blob, pathname, filename, url); + } + // console.log('got filesystem', filesystem); + + const model = await _loadModelFilesystem(filesystem); + return model; } else if (fileType === 'tgz') { const unitypackageRes = await fetch(href); const arraybuffer = await unitypackageRes.arrayBuffer(); @@ -562,19 +560,22 @@

Multiplayer

} } } - _loadModelFilesystem(filesystem); + const model = await _loadModelFilesystem(filesystem); + return model; } else { throw new Error(`unknown file type: ${filename} (${fileType})`); } }; const _bindUploadFileButton = inputFileEl => { - inputFileEl.addEventListener('change', e => { + inputFileEl.addEventListener('change', async e => { const {files} = e.target; if (files.length === 1) { const [file] = files; const dataUrl = URL.createObjectURL(file); - _loadModelUrl(dataUrl, file.name); + const model = await _loadModelUrl(dataUrl, file.name); + _setLocalModel(model); + // modelUrl = dataUrl; } const {parentNode} = inputFileEl; @@ -603,7 +604,9 @@

Multiplayer

const file = e.dataTransfer.items[i].getAsFile(); // console.log('got file', e.dataTransfer.items[i], file); const dataUrl = URL.createObjectURL(file); - _loadModelUrl(dataUrl, file.name); + const model = await _loadModelUrl(dataUrl, file.name); + _setLocalModel(model); + // modelUrl = dataUrl; } } }); @@ -627,11 +630,13 @@

Multiplayer

const aAvatars = Array.from(document.querySelectorAll('.a-avatar')); for (let i = 0; i < aAvatars.length; i++) { const aAvatar = aAvatars[i]; - aAvatar.addEventListener('click', e => { + aAvatar.addEventListener('click', async e => { e.preventDefault(); const {href} = aAvatar; - _loadModelUrl(href); + const model = await _loadModelUrl(href); + _setLocalModel(model); + modelUrl = href; }); } @@ -724,9 +729,10 @@

Multiplayer

let rig = null; let model = null; +let modelUrl = ''; // let heightOffset = 0; let heightFactor = 0; -const _rigModel = object => { +const _setLocalModel = object => { if (rig) { meshDolly.remove(model); rig = null; @@ -1038,7 +1044,10 @@

Multiplayer

enableMicButton.style.display = null; } - _loadModelUrl(aAvatars[0].href); + const url = aAvatars[0].href; + const model = await _loadModelUrl(url); + _setLocalModel(model); + modelUrl = url; })(); From 7e48b88f10cf5c889b1a20ea6777d5dba9497484 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 03:17:30 -0400 Subject: [PATCH 324/562] Add random date offset to model posing --- vrarmik.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index 21a3102..c7f0e90 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -764,7 +764,8 @@

Multiplayer

}; const lastPresseds = [false, false]; -const realDateNow = (now => () => now())(Date.now);//() => 2000; +const dateOffset = Math.floor(Math.random() * 60 * 1000); +const realDateNow = (now => () => dateOffset + now())(Date.now); function animate(timestamp, frame, referenceSpace) { if (rig) { if (renderer.vr.enabled) { From c9097f9229da462db63866ab0e8ab69290f3332d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 03:17:59 -0400 Subject: [PATCH 325/562] Add initial multiplayer support --- vrarmik.html | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) diff --git a/vrarmik.html b/vrarmik.html index c7f0e90..7fd8106 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -228,6 +228,7 @@ +
@@ -921,6 +922,13 @@

Multiplayer

meshes.footRight.quaternion.copy(rig.outputs.rightFoot.rotation); } + for (let i = 0; i < peerConnections.length; i++) { + const peerConnection = peerConnections[i]; + if (peerConnection.rig) { + peerConnection.rig.update(); + } + } + renderer.render(scene, camera); } renderer.setAnimationLoop(animate); @@ -1012,6 +1020,119 @@

Multiplayer

} }); */ +const peerConnections = []; +const channelInput = document.getElementById('channel-input'); +const connectButton = document.getElementById('connect-button'); +connectButton.addEventListener('click', () => { + const channelInputValue = channelInput.value; + const match = channelInputValue.match(/^(.+?)\/(.+?)$/); + if (match) { + const userName = match[1]; + const channelName = match[2]; + + console.log(`connecting to ${userName}/${channelName}`); + + const channelConnection = new XRChannelConnection(`wss://presence.exokit.org/?u=${encodeURIComponent(userName)}&c=${encodeURIComponent(channelName)}`); + channelConnection.addEventListener('open', () => { + console.log('xr channel open'); + }); + channelConnection.addEventListener('error', err => { + console.warn('xr channel error', err); + }); + channelConnection.addEventListener('peerconnection', e => { + const peerConnection = e.detail; + + peerConnection.model = null; + peerConnection.rig = null; + let updateInterval = 0; + peerConnection.addEventListener('open', () => { + console.log('add peer connection', peerConnection); + + peerConnections.push(peerConnection); + + peerConnection.send(JSON.stringify({ + method: 'model', + url: modelUrl, + })); + + updateInterval = setInterval(() => { + if (rig) { + const hmd = { + position: rig.inputs.hmd.position.toArray(), + quaternion: rig.inputs.hmd.rotation.toArray(), + }; + const gamepads = [ + { + position: rig.inputs.leftGamepad.position.toArray(), + quaternion: rig.inputs.leftGamepad.rotation.toArray(), + visible: true, + }, + { + position: rig.inputs.rightGamepad.position.toArray(), + quaternion: rig.inputs.rightGamepad.rotation.toArray(), + visible: true, + }, + ]; + peerConnection.update(hmd, gamepads); + } + }, 20); + }); + peerConnection.addEventListener('close', () => { + console.log('remove peer connection', peerConnection); + + const index = peerConnections.indexOf(peerConnection); + if (index !== -1) { + peerConnections.splice(index, 1); + } + + clearInterval(updateInterval); + + if (peerConnection.model) { + scene.remove(peerConnection.model); + } + }); + peerConnection.addEventListener('pose', e => { + const {rig} = peerConnection; + if (rig) { + const {detail: data} = e; + const {hmd, gamepads} = data; + + rig.inputs.hmd.rotation = new Quaternion().fromArray(hmd.quaternion); + rig.inputs.hmd.position = new Vector3().fromArray(hmd.position); + + rig.inputs.leftGamepad.rotation = new Quaternion().fromArray(gamepads[0].quaternion); + rig.inputs.leftGamepad.position = new Vector3().fromArray(gamepads[0].position); + + rig.inputs.rightGamepad.rotation = new Quaternion().fromArray(gamepads[1].quaternion); + rig.inputs.rightGamepad.position = new Vector3().fromArray(gamepads[1].position); + } + }); + peerConnection.addEventListener('message', async e => { + console.log('got message', e); + const data = JSON.parse(e.data); + const {method} = data; + if (method === 'model') { + const {url} = data; + console.log('got peer model', {url}); + + peerConnection.model = await _loadModelUrl(url); + scene.add(peerConnection.model); + peerConnection.rig = new Rig(peerConnection.model, { + hair: true, + visemes: true, + }); + } else { + console.warn('invalid method', {method}); + } + }); + }); + + connectButton.style.display = 'none'; + } else { + console.warn(`invalid user/channel: ${channelInputValue}`); + } +}); + (async () => { let result; if (navigator.xr) { From a748bf38cf696879561c816193e06ab554ec3021 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 03:20:33 -0400 Subject: [PATCH 326/562] Do not auto-enable mic --- vrarmik.html | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 7fd8106..4fc2756 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -1154,7 +1154,7 @@

Multiplayer

noXrButton.style.display = null; } - const microphonePermission = await navigator.permissions.query({ + /* const microphonePermission = await navigator.permissions.query({ name: 'microphone', }); if (microphonePermission.state === 'granted') { @@ -1164,7 +1164,8 @@

Multiplayer

disableMicButton.style.display = null; } else { enableMicButton.style.display = null; - } + } */ + enableMicButton.style.display = null; const url = aAvatars[0].href; const model = await _loadModelUrl(url); From f3a4cd0189559549a11f0f108076f67b352a4d09 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 04:26:59 -0400 Subject: [PATCH 327/562] Add peer connection lerp support --- vrarmik.html | 51 ++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 44 insertions(+), 7 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 4fc2756..8c76cee 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -281,6 +281,8 @@

Multiplayer

import Rig from './vrarmik/Rig.js'; import {Vector3, Quaternion} from './vrarmik/Unity.js'; +const peerPoseUpdateRate = 20; + const scene = new THREE.Scene(); const camera = new THREE.PerspectiveCamera(90, window.innerWidth / window.innerHeight, 0.1, 1000); @@ -1075,7 +1077,7 @@

Multiplayer

]; peerConnection.update(hmd, gamepads); } - }, 20); + }, peerPoseUpdateRate); }); peerConnection.addEventListener('close', () => { console.log('remove peer connection', peerConnection); @@ -1097,14 +1099,16 @@

Multiplayer

const {detail: data} = e; const {hmd, gamepads} = data; - rig.inputs.hmd.rotation = new Quaternion().fromArray(hmd.quaternion); - rig.inputs.hmd.position = new Vector3().fromArray(hmd.position); + rig.targets.hmd.position.fromArray(hmd.position); + rig.targets.hmd.rotation.fromArray(hmd.quaternion); + + rig.targets.gamepads[0].position.fromArray(gamepads[0].position); + rig.targets.gamepads[0].rotation.fromArray(gamepads[0].quaternion); - rig.inputs.leftGamepad.rotation = new Quaternion().fromArray(gamepads[0].quaternion); - rig.inputs.leftGamepad.position = new Vector3().fromArray(gamepads[0].position); + rig.targets.gamepads[1].position.fromArray(gamepads[1].position); + rig.targets.gamepads[1].rotation.fromArray(gamepads[1].quaternion); - rig.inputs.rightGamepad.rotation = new Quaternion().fromArray(gamepads[1].quaternion); - rig.inputs.rightGamepad.position = new Vector3().fromArray(gamepads[1].position); + rig.targets.timestamp = Date.now(); } }); peerConnection.addEventListener('message', async e => { @@ -1121,6 +1125,39 @@

Multiplayer

hair: true, visemes: true, }); + peerConnection.rig.targets = { + hmd: { + position: new Vector3(), + rotation: new Quaternion(), + }, + gamepads: [ + { + position: new Vector3(), + rotation: new Quaternion(), + }, + { + position: new Vector3(), + rotation: new Quaternion(), + }, + ], + timestamp: Date.now(), + }; + peerConnection.rig.update = (_update => function update() { + const now = Date.now(); + const {timestamp} = peerConnection.rig.targets; + const lerpFactor = Math.min(Math.max((now - timestamp) / peerPoseUpdateRate, 0), 1); + + peerConnection.rig.inputs.hmd.rotation = peerConnection.rig.inputs.hmd.rotation.slerp(peerConnection.rig.targets.hmd.rotation, lerpFactor); + peerConnection.rig.inputs.hmd.position = peerConnection.rig.inputs.hmd.position.lerp(peerConnection.rig.targets.hmd.position, lerpFactor); + + peerConnection.rig.inputs.leftGamepad.rotation = peerConnection.rig.inputs.leftGamepad.rotation.slerp(peerConnection.rig.targets.gamepads[0].rotation, lerpFactor); + peerConnection.rig.inputs.leftGamepad.position = peerConnection.rig.inputs.leftGamepad.position.lerp(peerConnection.rig.targets.gamepads[0].position, lerpFactor); + + peerConnection.rig.inputs.rightGamepad.rotation = peerConnection.rig.inputs.rightGamepad.rotation.slerp(peerConnection.rig.targets.gamepads[1].rotation, lerpFactor); + peerConnection.rig.inputs.rightGamepad.position = peerConnection.rig.inputs.rightGamepad.position.lerp(peerConnection.rig.targets.gamepads[1].position, lerpFactor); + + _update.apply(this, arguments); + })(peerConnection.rig.update); } else { console.warn('invalid method', {method}); } From d40a37472493c14b7d14e7f1589c03c7adf9c83f Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 04:38:19 -0400 Subject: [PATCH 328/562] Feet jump rotation cleanup --- vrarmik/LegsManager.js | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index a21c1b2..3a47904 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -141,7 +141,7 @@ class Leg extends MonoBehavior { } else { this.upperLeg.localRotation = this.upperLeg.localRotation.slerp(new Quaternion(), 0.1); this.lowerLeg.localRotation = this.lowerLeg.localRotation.slerp(new Quaternion(), 0.1); - this.foot.localRotation = this.foot.localRotation.slerp(new Quaternion().setFromUnitVectors(new Vector3(0, -1, 0), new Vector3(0, 0, 1)), 0.1); + this.foot.localRotation = this.foot.localRotation.slerp(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/4), 0.1); // this.foot.position = footPosition; /* const direction = this.foot.position.sub(this.upperLeg.position).normalize().lerp(new Vector3(0, -1, 0), 0.1); const lowerLegPosition = this.upperLeg.position.add(direction.clone().multiplyScalar(upperLegLength)); @@ -226,39 +226,35 @@ class LegsManager extends MonoBehavior if (this.leftLeg.standing) { const leftFootEuler = new THREE.Euler().setFromQuaternion(leftFootRotation, 'YXZ'); + leftFootEuler.x = 0; + leftFootEuler.z = 0; if (leftFootEuler.y < -Math.PI*0.15) { leftFootEuler.y = -Math.PI*0.15; - new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(leftFootEuler), Vector3.one) - .premultiply(planeMatrix) - .decompose(position, quaternion, scale); - this.leftLeg.foot.stickTransform.rotation = quaternion; } if (leftFootEuler.y > Math.PI*0.15) { leftFootEuler.y = Math.PI*0.15; - new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(leftFootEuler), Vector3.one) - .premultiply(planeMatrix) - .decompose(position, quaternion, scale); - this.leftLeg.foot.stickTransform.rotation = quaternion; } + new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(leftFootEuler), Vector3.one) + .premultiply(planeMatrix) + .decompose(position, quaternion, scale); + this.leftLeg.foot.stickTransform.rotation = quaternion; } else { this.leftLeg.foot.stickTransform.rotation = this.leftLeg.foot.rotation.multiply(new Quaternion().setFromUnitVectors(new Vector3(0, -1, 0), new Vector3(0, 0, 1)).inverse()); } if (this.rightLeg.standing) { const rightFootEuler = new THREE.Euler().setFromQuaternion(rightFootRotation, 'YXZ'); + rightFootEuler.x = 0; + rightFootEuler.z = 0; if (rightFootEuler.y < -Math.PI*0.15) { rightFootEuler.y = -Math.PI*0.15; - new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(rightFootEuler), Vector3.one) - .premultiply(planeMatrix) - .decompose(position, quaternion, scale); - this.rightLeg.foot.stickTransform.rotation = quaternion; } if (rightFootEuler.y > Math.PI*0.15) { rightFootEuler.y = Math.PI*0.15; - new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(rightFootEuler), Vector3.one) - .premultiply(planeMatrix) - .decompose(position, quaternion, scale); - this.rightLeg.foot.stickTransform.rotation = quaternion; } + new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(rightFootEuler), Vector3.one) + .premultiply(planeMatrix) + .decompose(position, quaternion, scale); + this.rightLeg.foot.stickTransform.rotation = quaternion; } else { this.rightLeg.foot.stickTransform.rotation = this.rightLeg.foot.rotation.multiply(new Quaternion().setFromUnitVectors(new Vector3(0, -1, 0), new Vector3(0, 0, 1)).inverse()); } From 60006f4d9df5d3fd896fecf126fe37341f4fec78 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 16:10:59 -0400 Subject: [PATCH 329/562] Bugfix disconect typo --- multiplayer.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/multiplayer.js b/multiplayer.js index 74da2b2..a524616 100644 --- a/multiplayer.js +++ b/multiplayer.js @@ -157,7 +157,7 @@ class XRChannelConnection extends EventTarget { }, 30*1000); } - disconect() { + disconnect() { this.rtcWs.close(); this.rtcWs = null; From 22e094af45064dfad03b055045128641377c0e89 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 18:56:09 -0400 Subject: [PATCH 330/562] Add avatars microphone media stream processing --- multiplayer.js | 46 ++++++++++++++++++++++++++++++++++++++++++++-- vrarmik.html | 22 +++++++++++++++++++++- vrarmik/Rig.js | 39 ++++++++++++++++++++++++++------------- 3 files changed, 91 insertions(+), 16 deletions(-) diff --git a/multiplayer.js b/multiplayer.js index a524616..2a32da2 100644 --- a/multiplayer.js +++ b/multiplayer.js @@ -8,12 +8,13 @@ function _randomString() { } class XRChannelConnection extends EventTarget { - constructor(url) { + constructor(url, options = {}) { super(); this.rtcWs = new WebSocket(url); this.connectionId = _randomString(); this.peerConnections = []; + this.microphoneMediaStream = options.microphoneMediaStream; this.rtcWs.onopen = () => { // console.log('presence socket open'); @@ -42,6 +43,13 @@ class XRChannelConnection extends EventTarget { this.peerConnections.splice(index, 1); } }); + if (this.microphoneMediaStream) { + // peerConnection.peerConnection.addStream(this.microphoneMediaStream); + const tracks = this.microphoneMediaStream.getAudioTracks(); + for (let i = 0; i < tracks.length; i++) { + peerConnection.peerConnection.addTrack(tracks[i]); + } + } peerConnection.peerConnection.onicecandidate = e => { // console.log('ice candidate', e.candidate); @@ -179,6 +187,31 @@ class XRChannelConnection extends EventTarget { } } } + + setMicrophoneMediaStream(microphoneMediaStream) { + const {microphoneMediaStream: oldMicrophoneMediaStream} = this; + if (oldMicrophoneMediaStream) { + const oldTracks = oldMicrophoneMediaStream.getAudioTracks(); + for (let i = 0; i < this.peerConnections.length; i++) { + const peerConnection = this.peerConnections[i]; + for (let j = 0; j < oldTracks.length; j++) { + peerConnection.removeTrack(oldTracks[j]); + } + } + } + + this.microphoneMediaStream = microphoneMediaStream; + + if (microphoneMediaStream) { + const tracks = microphoneMediaStream.getAudioTracks(); + for (let i = 0; i < this.peerConnections.length; i++) { + const peerConnection = this.peerConnections[i]; + for (let j = 0; j < tracks.length; j++) { + peerConnection.addTrack(tracks[j]); + } + } + } + } } window.XRChannelConnection = XRChannelConnection; @@ -193,8 +226,17 @@ class XRPeerConnection extends EventTarget { }); this.open = false; + /* this.peerConnection.onaddstream = e => { + this.dispatchEvent(new CustomEvent('mediastream', { + detail: e.stream, + })); + }; */ this.peerConnection.ontrack = e => { - console.log('got track', e); + const mediaStream = new MediaStream(); + mediaStream.addTrack(e.track); + this.dispatchEvent(new CustomEvent('mediastream', { + detail: mediaStream, + })); }; const sendChannel = this.peerConnection.createDataChannel('sendChannel'); diff --git a/vrarmik.html b/vrarmik.html index 8c76cee..74eeabf 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -999,6 +999,12 @@

Multiplayer

microphoneMediaStream = await navigator.mediaDevices.getUserMedia({ audio: true, }); + + rig.setMicrophoneMediaStream(microphoneMediaStream); + if (channelConnection) { + channelConnection.setMicrophoneMediaStream(microphoneMediaStream); + } + disableMicButton.style.display = null; enableMicButton.style.display = 'none'; } catch (err) { @@ -1022,6 +1028,7 @@

Multiplayer

} }); */ +let channelConnection = null; const peerConnections = []; const channelInput = document.getElementById('channel-input'); const connectButton = document.getElementById('connect-button'); @@ -1034,7 +1041,9 @@

Multiplayer

console.log(`connecting to ${userName}/${channelName}`); - const channelConnection = new XRChannelConnection(`wss://presence.exokit.org/?u=${encodeURIComponent(userName)}&c=${encodeURIComponent(channelName)}`); + channelConnection = new XRChannelConnection(`wss://presence.exokit.org/?u=${encodeURIComponent(userName)}&c=${encodeURIComponent(channelName)}`, { + microphoneMediaStream, + }); channelConnection.addEventListener('open', () => { console.log('xr channel open'); }); @@ -1046,6 +1055,7 @@

Multiplayer

peerConnection.model = null; peerConnection.rig = null; + peerConnection.mediaStream = null; let updateInterval = 0; peerConnection.addEventListener('open', () => { console.log('add peer connection', peerConnection); @@ -1111,6 +1121,13 @@

Multiplayer

rig.targets.timestamp = Date.now(); } }); + peerConnection.addEventListener('mediastream', e => { + console.log('got media stream', e.detail, e.detail.getAudioTracks()); + peerConnection.mediaStream = e.detail; + if (peerConnection.rig) { + peerConnection.rig.setMicrophoneMediaStream(peerConnection.mediaStream); + } + }); peerConnection.addEventListener('message', async e => { console.log('got message', e); const data = JSON.parse(e.data); @@ -1121,10 +1138,13 @@

Multiplayer

peerConnection.model = await _loadModelUrl(url); scene.add(peerConnection.model); + peerConnection.rig = new Rig(peerConnection.model, { hair: true, visemes: true, + microphoneMediaStream: peerConnection.mediaStream, }); + peerConnection.rig.targets = { hmd: { position: new Vector3(), diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index b44bfec..1fd6389 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -651,20 +651,9 @@ class Rig { Right_ankle: this.outputs.leftFoot, }; + this.audioContext = null; this.volume = 0; - if (options.microphoneMediaStream) { - (async () => { - const context = new AudioContext(); - const mediaStreamSource = context.createMediaStreamSource(options.microphoneMediaStream); - - await context.audioWorklet.addModule('vrarmik/audio-volume-worklet.js'); - const audioWorkletNode = new AudioWorkletNode(context, 'volume-processor'); - audioWorkletNode.port.onmessage = e => { - this.volume = this.volume*0.8 + e.data*0.2; - }; - mediaStreamSource.connect(audioWorkletNode).connect(context.destination); - })(); - } + this.setMicrophoneMediaStream(options.microphoneMediaStream); this.lastTimestamp = Date.now(); @@ -860,5 +849,29 @@ class Rig { }); } } + + async setMicrophoneMediaStream(microphoneMediaStream) { + if (this.audioContext) { + this.audioContext.close(); + this.audioContext = null; + setTimeout(() => { + this.volume = 0; + }); + } + if (microphoneMediaStream) { + const audio = document.createElement('audio'); + audio.srcObject = microphoneMediaStream; + audio.muted = true; + this.audioContext = new AudioContext(); + const mediaStreamSource = this.audioContext.createMediaStreamSource(microphoneMediaStream); + + await this.audioContext.audioWorklet.addModule('vrarmik/audio-volume-worklet.js'); + const audioWorkletNode = new AudioWorkletNode(this.audioContext, 'volume-processor'); + audioWorkletNode.port.onmessage = e => { + this.volume = this.volume*0.8 + e.data*0.2; + }; + mediaStreamSource.connect(audioWorkletNode).connect(this.audioContext.destination); + } + } } export default Rig; \ No newline at end of file From 828284c3c27cc04e5cf647570035c332d8aa1302 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 18:56:23 -0400 Subject: [PATCH 331/562] Add mic disable support --- vrarmik.html | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 74eeabf..3e0de08 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -269,7 +269,7 @@

Multiplayer

- +
@@ -1011,22 +1011,27 @@

Multiplayer

console.warn(err); } }); -/* disableMicButton.addEventListener('click', async () => { - microphoneMediaStream.getTracks().forEach(track => { +disableMicButton.addEventListener('click', async () => { + rig.setMicrophoneMediaStream(null); + if (channelConnection) { + channelConnection.setMicrophoneMediaStream(null); + } + microphoneMediaStream.getAudioTracks().forEach(track => { track.stop(); }); + microphoneMediaStream = null; enableMicButton.style.display = null; disableMicButton.style.display = 'none'; - try { + /* try { await navigator.permissions.revoke({ name: 'microphone', }); } catch(err) { console.warn(err); - } -}); */ + } */ +}); let channelConnection = null; const peerConnections = []; From d817816b32076e524ff234459060c80a8357fe23 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 18:58:02 -0400 Subject: [PATCH 332/562] Add audio volume worklet passthrough --- vrarmik/audio-volume-worklet.js | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/vrarmik/audio-volume-worklet.js b/vrarmik/audio-volume-worklet.js index c223785..a4cadcd 100644 --- a/vrarmik/audio-volume-worklet.js +++ b/vrarmik/audio-volume-worklet.js @@ -26,6 +26,15 @@ class VolumeProcessor extends AudioWorkletProcessor { numSamples = 0; } + for (let i = 0; i < outputs.length; i++) { + const input = inputs[i]; + const output = outputs[i]; + + for (let channel = 0; channel < output.length; channel++) { + output[channel].set(input[channel]); + } + } + return true; } } From cfb1de5b3b252c22127b10b9e4b83c0f16470abd Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 20:47:19 -0400 Subject: [PATCH 333/562] Major multiplayer.js offer renegotiation bugfixing --- multiplayer.js | 79 ++++++++++++++++++++++++++++++++++---------------- 1 file changed, 54 insertions(+), 25 deletions(-) diff --git a/multiplayer.js b/multiplayer.js index 2a32da2..a3240ce 100644 --- a/multiplayer.js +++ b/multiplayer.js @@ -34,22 +34,12 @@ class XRChannelConnection extends EventTarget { } if (!peerConnection) { peerConnection = new XRPeerConnection(peerConnectionId); - this.dispatchEvent(new CustomEvent('peerconnection', { - detail: peerConnection, - })); peerConnection.addEventListener('close', () => { const index = this.peerConnections.indexOf(peerConnection); if (index !== -1) { this.peerConnections.splice(index, 1); } }); - if (this.microphoneMediaStream) { - // peerConnection.peerConnection.addStream(this.microphoneMediaStream); - const tracks = this.microphoneMediaStream.getAudioTracks(); - for (let i = 0; i < tracks.length; i++) { - peerConnection.peerConnection.addTrack(tracks[i]); - } - } peerConnection.peerConnection.onicecandidate = e => { // console.log('ice candidate', e.candidate); @@ -60,21 +50,23 @@ class XRChannelConnection extends EventTarget { candidate: e.candidate, })); }; + this.peerConnections.push(peerConnection); + this.dispatchEvent(new CustomEvent('peerconnection', { + detail: peerConnection, + })); - if (this.connectionId < peerConnectionId) { - peerConnection.peerConnection - .createOffer() - .then(offer => { - peerConnection.peerConnection.setLocalDescription(offer); + if (this.microphoneMediaStream) { + // peerConnection.peerConnection.addStream(this.microphoneMediaStream); + const tracks = this.microphoneMediaStream.getAudioTracks(); + for (let i = 0; i < tracks.length; i++) { + // console.log('add track for remote', tracks[i]); + peerConnection.peerConnection.addTrack(tracks[i]); + } + } - this.rtcWs.send(JSON.stringify({ - dst: peerConnectionId, - src: this.connectionId, - method: 'offer', - offer, - })); - }); + if (this.connectionId < peerConnectionId) { + _startOffer(peerConnection); } } }; @@ -86,6 +78,22 @@ class XRChannelConnection extends EventTarget { console.warn('no such peer connection', peerConnectionId, this.peerConnections.map(peerConnection => peerConnection.connectionId)); } }; + const _startOffer = peerConnection => { + peerConnection.peerConnection + .createOffer() + .then(offer => { + // console.log('create offer'); + return peerConnection.peerConnection.setLocalDescription(offer).then(() => offer); + }) + .then(offer => { + this.rtcWs.send(JSON.stringify({ + dst: peerConnection.connectionId, + src: this.connectionId, + method: 'offer', + offer, + })); + }); + }; this.rtcWs.onmessage = e => { // console.log('got message', e.data); @@ -100,16 +108,34 @@ class XRChannelConnection extends EventTarget { const peerConnection = this.peerConnections.find(peerConnection => peerConnection.connectionId === peerConnectionId); if (peerConnection) { peerConnection.peerConnection.setRemoteDescription(offer) - .then(() => peerConnection.peerConnection.createAnswer()) + .then(() => { + // console.log('create answer'); + return peerConnection.peerConnection.createAnswer(); + }) + .then(answer => peerConnection.peerConnection.setLocalDescription(answer).then(() => answer)) .then(answer => { - peerConnection.peerConnection.setLocalDescription(answer); - this.rtcWs.send(JSON.stringify({ dst: peerConnectionId, src: this.connectionId, method: 'answer', answer, })); + }).then(() => new Promise((accept, reject) => { + const _recurse = () => { + if (peerConnection.peerConnection.signalingState === 'stable') { + accept(); + } else { + peerConnection.peerConnection.addEventListener('signalingstatechange', _recurse, { + once: true, + }); + } + }; + _recurse(); + })) + .then(() => { + if (this.connectionId >= peerConnectionId && this.microphoneMediaStream) { + _startOffer(peerConnection); + } }); } else { console.warn('no such peer connection', peerConnectionId, this.peerConnections.map(peerConnection => peerConnection.connectionId)); @@ -226,6 +252,9 @@ class XRPeerConnection extends EventTarget { }); this.open = false; + /* this.peerConnection.onnegotiationneeded = e => { + console.log('negotiation needed'); + }; */ /* this.peerConnection.onaddstream = e => { this.dispatchEvent(new CustomEvent('mediastream', { detail: e.stream, From 76b52be62a5db137d72a46c2b0d8804c2e0a9db3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 21:01:10 -0400 Subject: [PATCH 334/562] Add audo volume worklet muted message support --- vrarmik/audio-volume-worklet.js | 27 +++++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-) diff --git a/vrarmik/audio-volume-worklet.js b/vrarmik/audio-volume-worklet.js index a4cadcd..0c8820a 100644 --- a/vrarmik/audio-volume-worklet.js +++ b/vrarmik/audio-volume-worklet.js @@ -3,8 +3,22 @@ const numTicks = 1; let tick = 0; let sampleSum = 0; let numSamples = 0; +let muted = true; class VolumeProcessor extends AudioWorkletProcessor { + constructor() { + super(); + + this.port.addEventListener('message', e => { + const data = JSON.parse(e.data); + console.log('got worklet data', e.data); + const {method} = data; + if (method === 'muted') { + muted = data.muted; + } + }); + this.port.start(); + } process(inputs, outputs) { const channels = inputs[0]; // const output = outputs[0]; @@ -26,17 +40,18 @@ class VolumeProcessor extends AudioWorkletProcessor { numSamples = 0; } - for (let i = 0; i < outputs.length; i++) { - const input = inputs[i]; - const output = outputs[i]; + if (!muted) { + for (let i = 0; i < outputs.length; i++) { + const input = inputs[i]; + const output = outputs[i]; - for (let channel = 0; channel < output.length; channel++) { - output[channel].set(input[channel]); + for (let channel = 0; channel < output.length; channel++) { + output[channel].set(input[channel]); + } } } return true; } } - registerProcessor('volume-processor', VolumeProcessor); \ No newline at end of file From cd5ae6401af500ff534e5120be5ef54a0f044e1e Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 21:02:18 -0400 Subject: [PATCH 335/562] Configure remove microphone media streams as non-muted --- vrarmik.html | 5 ++++- vrarmik/Rig.js | 12 ++++++++++-- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 3e0de08..50aaf5b 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -1130,7 +1130,9 @@

Multiplayer

console.log('got media stream', e.detail, e.detail.getAudioTracks()); peerConnection.mediaStream = e.detail; if (peerConnection.rig) { - peerConnection.rig.setMicrophoneMediaStream(peerConnection.mediaStream); + peerConnection.rig.setMicrophoneMediaStream(peerConnection.mediaStream, { + muted: false, + }); } }); peerConnection.addEventListener('message', async e => { @@ -1148,6 +1150,7 @@

Multiplayer

hair: true, visemes: true, microphoneMediaStream: peerConnection.mediaStream, + muted: false, }); peerConnection.rig.targets = { diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 1fd6389..81a745d 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -653,7 +653,9 @@ class Rig { this.audioContext = null; this.volume = 0; - this.setMicrophoneMediaStream(options.microphoneMediaStream); + this.setMicrophoneMediaStream(options.microphoneMediaStream, { + muted: options.muted, + }); this.lastTimestamp = Date.now(); @@ -850,7 +852,7 @@ class Rig { } } - async setMicrophoneMediaStream(microphoneMediaStream) { + async setMicrophoneMediaStream(microphoneMediaStream, options = {}) { if (this.audioContext) { this.audioContext.close(); this.audioContext = null; @@ -867,6 +869,12 @@ class Rig { await this.audioContext.audioWorklet.addModule('vrarmik/audio-volume-worklet.js'); const audioWorkletNode = new AudioWorkletNode(this.audioContext, 'volume-processor'); + if (options.muted === false) { + audioWorkletNode.port.postMessage(JSON.stringify({ + method: 'muted', + muted: false, + })); + } audioWorkletNode.port.onmessage = e => { this.volume = this.volume*0.8 + e.data*0.2; }; From 8b0270c9d09acd7961d3c2e8fc59f98ebff79f78 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 21:06:21 -0400 Subject: [PATCH 336/562] Small logging cleanup --- vrarmik/audio-volume-worklet.js | 1 - 1 file changed, 1 deletion(-) diff --git a/vrarmik/audio-volume-worklet.js b/vrarmik/audio-volume-worklet.js index 0c8820a..3e1f4ca 100644 --- a/vrarmik/audio-volume-worklet.js +++ b/vrarmik/audio-volume-worklet.js @@ -11,7 +11,6 @@ class VolumeProcessor extends AudioWorkletProcessor { this.port.addEventListener('message', e => { const data = JSON.parse(e.data); - console.log('got worklet data', e.data); const {method} = data; if (method === 'muted') { muted = data.muted; From 94d23e71b4e47f93871db8231481a41d9e965fbf Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 23:30:56 -0400 Subject: [PATCH 337/562] Small legs cleanup --- vrarmik/LegsManager.js | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 3a47904..9da68ec 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -9,10 +9,9 @@ const _angleDiff = (targetA, sourceA) => { return a; }; -class Leg extends MonoBehavior { - constructor(...args) { - super(...args); - +class Leg { + constructor() { + this.transform = new Transform(); this.upperLeg = new Transform(); this.lowerLeg = new Transform(); this.foot = new Transform(); @@ -179,9 +178,9 @@ class LegsManager extends MonoBehavior const shoulderTransforms = this.GetOrAddComponent(ShoulderTransforms); this.hips = shoulderTransforms.hips; - this.leftLeg = unity.makeGameObject().AddComponent(Leg); + this.leftLeg = new Leg(); this.hips.AddChild(this.leftLeg.transform); - this.rightLeg = unity.makeGameObject().AddComponent(Leg); + this.rightLeg = new Leg(); this.hips.AddChild(this.rightLeg.transform); this.rightLeg.foot.stickTransform.position = this.rightLeg.foot.position; @@ -195,6 +194,8 @@ class LegsManager extends MonoBehavior Start() { this.legSeparation = this.leftLeg.upperLeg.position.distanceTo(this.rightLeg.upperLeg.position); + this.leftLeg.Start(); + this.rightLeg.Start(); } LateUpdate() { @@ -287,6 +288,9 @@ class LegsManager extends MonoBehavior footPosition.y = 0; this.rightLeg.foot.stickTransform.position = footPosition; } + + this.leftLeg.LateUpdate(); + this.rightLeg.LateUpdate(); } } From 944ff0984f24c5e99c90b0c33db3b359f06b2414 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 23:42:11 -0400 Subject: [PATCH 338/562] More legs manager cleanup --- vrarmik/LegsManager.js | 14 ++++---------- vrarmik/Rig.js | 3 ++- 2 files changed, 6 insertions(+), 11 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 9da68ec..26e109f 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -1,6 +1,4 @@ import {Vector2, Vector3, Quaternion, Transform, GameObject, MonoBehavior, XRSettings} from './Unity.js'; -import PoseManager from './PoseManager.js'; -import ShoulderTransforms from './ShoulderTransforms.js'; const _mod = (a, n) => (a % n + n) % n; const _angleDiff = (targetA, sourceA) => { @@ -171,13 +169,9 @@ class Leg { } } -class LegsManager extends MonoBehavior -{ - constructor(transform, components, unity) { - super(transform, components, unity); - - const shoulderTransforms = this.GetOrAddComponent(ShoulderTransforms); - this.hips = shoulderTransforms.hips; +class LegsManager { + constructor(rig) { + this.hips = rig.shoulderTransforms.hips; this.leftLeg = new Leg(); this.hips.AddChild(this.leftLeg.transform); this.rightLeg = new Leg(); @@ -186,7 +180,7 @@ class LegsManager extends MonoBehavior this.rightLeg.foot.stickTransform.position = this.rightLeg.foot.position; this.rightLeg.left = false; - this.poseManager = this.GetOrAddComponent(PoseManager); + this.poseManager = rig.poseManager; this.leftLeg.poseManager = this.poseManager; this.rightLeg.poseManager = this.poseManager; // this.hmdTransformRef = poseManager.vrTransforms.head; diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 81a745d..43dcf9f 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -569,7 +569,8 @@ class Rig { this.poseManager = rigObject.AddComponent(PoseManager); this.poseManager.flipY = flipY; this.shoulderTransforms = rigObject.AddComponent(ShoulderTransforms); - this.legsManager = rigObject.AddComponent(LegsManager); + this.legsManager = new LegsManager(this); + rigObject.components.set(LegsManager, this.legsManager); this.shoulderTransforms.spine.localPosition = setups.spine; this.shoulderTransforms.transform.localPosition = setups.chest; From bfe159649ec77c686cc0b59d9d045f1f08d633fb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 23:42:23 -0400 Subject: [PATCH 339/562] Bugfix unity emulation method calls --- vrarmik/Unity.js | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 42c6140..09ef38b 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -504,29 +504,29 @@ class Unity { startAll() { for (let i = 0; i < this.gameObjects.length; i++) { this.gameObjects[i].components.forEach(value => { - value.Awake(); + value.Awake && value.Awake(); }); } for (let i = 0; i < this.gameObjects.length; i++) { this.gameObjects[i].components.forEach(value => { - value.OnEnable(); + value.OnEnable && value.OnEnable(); }); } for (let i = 0; i < this.gameObjects.length; i++) { this.gameObjects[i].components.forEach(value => { - value.Start(); + value.Start && value.Start(); }); } } updateAll() { for (let i = 0; i < this.gameObjects.length; i++) { this.gameObjects[i].components.forEach(value => { - value.Update(); + value.Update && value.Update(); }); } for (let i = 0; i < this.gameObjects.length; i++) { this.gameObjects[i].components.forEach(value => { - value.LateUpdate(); + value.LateUpdate && value.LateUpdate(); }); } } From c9bf9ab0b3431fe30f152933d4e9610daad5c104 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 23:46:06 -0400 Subject: [PATCH 340/562] Arm transforms dead code cleanup --- vrarmik/ArmTransforms.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index b900c78..c7eacfd 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,5 +1,5 @@ import {Vector3, Quaternion, Transform, MonoBehavior, Mathf} from './Unity.js'; -import PoseManager from './PoseManager.js'; +// import PoseManager from './PoseManager.js'; class ArmTransforms extends MonoBehavior { From 43b695a63e94aadb088f65f11805b57072601fbe Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 23:46:42 -0400 Subject: [PATCH 341/562] Avatar VR tracking references dead code cleanup --- vrarmik/AvatarVRTrackingReferences.js | 1 - 1 file changed, 1 deletion(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 2e731bf..0f99126 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,5 +1,4 @@ import {Vector3, GameObject, MonoBehavior} from './Unity.js'; -import PoseManager from './PoseManager.js'; import StaticOffsetTransform from './StaticOffsetTransform.js'; From d947d77adc2d45ee4428a9a7b673eecdc5c4ffc3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Mon, 28 Oct 2019 23:47:15 -0400 Subject: [PATCH 342/562] VRArmIK dead code cleanup --- vrarmik/VRArmIK.js | 1 - 1 file changed, 1 deletion(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index f1d429f..f293c75 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -2,7 +2,6 @@ import {Vector3, Quaternion, Transform, GameObject, MonoBehavior, Time, Mathf} f import ArmTransforms from './ArmTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; import VectorHelpers from './Utils/VectorHelpers.js'; -import PoseManager from './PoseManager.js'; class ArmIKElbowSettings { From 46dc8be30fd034037168bc9d8050a5c085080391 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 00:06:03 -0400 Subject: [PATCH 343/562] Major pose manager unity cleanup refactoring --- vrarmik/ArmTransforms.js | 1 - vrarmik/AvatarVRTrackingReferences.js | 23 +++++++++++++------ vrarmik/PoseManager.js | 32 ++++++++++++++++----------- vrarmik/Rig.js | 3 ++- vrarmik/StaticOffsetTransform.js | 8 +++---- vrarmik/VRTrackingReferences.js | 9 +++----- 6 files changed, 44 insertions(+), 32 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index c7eacfd..ec3c833 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,5 +1,4 @@ import {Vector3, Quaternion, Transform, MonoBehavior, Mathf} from './Unity.js'; -// import PoseManager from './PoseManager.js'; class ArmTransforms extends MonoBehavior { diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 0f99126..4072b07 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,24 +1,33 @@ -import {Vector3, GameObject, MonoBehavior} from './Unity.js'; +import {Vector3, Transform} from './Unity.js'; import StaticOffsetTransform from './StaticOffsetTransform.js'; - class AvatarVRTrackingReferences extends MonoBehavior + class AvatarVRTrackingReferences { - constructor(transform, components, unity) { - super(transform, components, unity); + constructor() { + this.transform = new Transform(); this.head = null; - // this.hmd = null; this.leftHand = null; this.rightHand = null; + // this.hmd = null; - this.unity = unity; this.poseManager = null; } Awake() { this.initTransforms(); + + this.head.Awake(); + this.leftHand.Awake(); + this.rightHand.Awake(); + } + + Update() { + this.head.Update(); + this.leftHand.Update(); + this.rightHand.Update(); } initTransforms() @@ -44,7 +53,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; let t = this[k]; if (t === null) { - t = this.unity.makeGameObject(name).AddComponent(StaticOffsetTransform); + t = new StaticOffsetTransform(); this.transform.AddChild(t.transform); this.setStaticOffsetSettings(t); this[k] = t; diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 455dc51..36a9fd8 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -1,14 +1,14 @@ import VRTrackingReferences from './VRTrackingReferences.js'; import AvatarVRTrackingReferences from './AvatarVRTrackingReferences.js'; -import {GameObject, MonoBehavior, XRSettings} from './Unity.js'; +import {Transform, XRSettings} from './Unity.js'; -class PoseManager extends MonoBehavior +class PoseManager { - constructor(transform, components, unity) { - super(transform, components, unity); + constructor() { + this.transform = new Transform(); - this.vrTransforms = unity.makeGameObject().AddComponent(VRTrackingReferences); - this.avatarVrTransforms = unity.makeGameObject().AddComponent(AvatarVRTrackingReferences); + this.vrTransforms = new VRTrackingReferences(); + this.avatarVrTransforms = new AvatarVRTrackingReferences(); this.avatarVrTransforms.poseManager = this; // this.OnCalibrateListener = null; @@ -42,13 +42,15 @@ class PoseManager extends MonoBehavior Awake() { - if (this.loadPlayerSizeOnAwake) - { - this.loadPlayerSize(); - } - const device = XRSettings.loadedDeviceName; - this.vrSystemOffsetHeight = /*string.IsNullOrEmpty(device) || */device == "OpenVR" ? 0 : this.playerHeightHmd; - } + if (this.loadPlayerSizeOnAwake) + { + this.loadPlayerSize(); + } + const device = XRSettings.loadedDeviceName; + this.vrSystemOffsetHeight = /*string.IsNullOrEmpty(device) || */device == "OpenVR" ? 0 : this.playerHeightHmd; + + this.avatarVrTransforms.Awake(); + } /* Start() { @@ -60,6 +62,10 @@ class PoseManager extends MonoBehavior this.playerHeightHmd = Camera.main.transform.position.y; } */ + Update() { + this.avatarVrTransforms.Update(); + } + loadPlayerWidthShoulders() { this.playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31); diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 43dcf9f..a1705b8 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -566,8 +566,9 @@ class Rig { }; const rigObject = this.unity.makeGameObject('rig'); - this.poseManager = rigObject.AddComponent(PoseManager); + this.poseManager = new PoseManager(); this.poseManager.flipY = flipY; + rigObject.components.set(PoseManager, this.poseManager); this.shoulderTransforms = rigObject.AddComponent(ShoulderTransforms); this.legsManager = new LegsManager(this); rigObject.components.set(LegsManager, this.legsManager); diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index cd54812..b094ca7 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion, MonoBehavior} from './Unity.js'; +import {Vector3, Quaternion, Transform} from './Unity.js'; const EulerOrder = { XYZ: 'XYZ', @@ -9,10 +9,10 @@ const EulerOrder = { ZYX: 'ZYX', }; -class StaticOffsetTransform extends MonoBehavior +class StaticOffsetTransform { - constructor(...args) { - super(...args); + constructor() { + this.transform = new Transform(); this.reference = null; this.offsetPosition = new Vector3(); diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index a9f5028..afb6efa 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -1,10 +1,7 @@ -import {Transform, MonoBehavior} from './Unity.js'; - - class VRTrackingReferences extends MonoBehavior - { - constructor(...args) { - super(...args); +import {Transform} from './Unity.js'; + class VRTrackingReferences { + constructor() { /* this.leftController = new Transform(); this.rightController = new Transform(); this.hmd = new Transform(); */ From 1df714d840d03532592c98cc6f2e9f444887c08e Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 00:32:02 -0400 Subject: [PATCH 344/562] Finish unity components extraction --- vrarmik/ArmTransforms.js | 9 ++-- vrarmik/AvatarVRTrackingReferences.js | 28 ++++++------ vrarmik/PoseManager.js | 7 +-- vrarmik/Rig.js | 5 +- vrarmik/ShoulderPoser.js | 12 ++--- vrarmik/ShoulderTransforms.js | 66 +++++++++++++++------------ vrarmik/StaticOffsetTransform.js | 4 +- vrarmik/VRArmIK.js | 13 ++---- 8 files changed, 70 insertions(+), 74 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index ec3c833..30779ac 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -1,10 +1,9 @@ -import {Vector3, Quaternion, Transform, MonoBehavior, Mathf} from './Unity.js'; +import {Vector3, Quaternion, Transform, Mathf} from './Unity.js'; -class ArmTransforms extends MonoBehavior +class ArmTransforms { - constructor(...args) { - super(...args); - + constructor() { + this.transform = new Transform(); this.upperArm = new Transform(); this.lowerArm = new Transform(); this.wrist1 = new Transform(); diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index 4072b07..e757c8b 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -4,7 +4,7 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; class AvatarVRTrackingReferences { - constructor() { + constructor(poseManager) { this.transform = new Transform(); this.head = null; @@ -12,17 +12,19 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; this.rightHand = null; // this.hmd = null; - this.poseManager = null; + this.poseManager = poseManager; + + this.initTransforms(); } - Awake() + /* Awake() { this.initTransforms(); this.head.Awake(); this.leftHand.Awake(); this.rightHand.Awake(); - } + } */ Update() { this.head.Update(); @@ -50,14 +52,10 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; createTransform(k) { - let t = this[k]; - if (t === null) - { - t = new StaticOffsetTransform(); - this.transform.AddChild(t.transform); - this.setStaticOffsetSettings(t); - this[k] = t; - } + const t = new StaticOffsetTransform(); + this.transform.AddChild(t.transform); + this.setStaticOffsetSettings(t); + this[k] = t; } /* createHandTransform(t, name, parent) @@ -86,10 +84,10 @@ import StaticOffsetTransform from './StaticOffsetTransform.js'; sot.reference = this.transform.parent; } */ - this.head.reference = this.head.reference !== null ? this.head.reference : this.poseManager.vrTransforms.head; + this.head.reference = this.poseManager.vrTransforms.head; // this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : this.poseManager.vrTransforms.hmd; - this.leftHand.reference = this.leftHand.reference !== null ? this.leftHand.reference : this.poseManager.vrTransforms.leftHand; - this.rightHand.reference = this.rightHand.reference !== null ? this.rightHand.reference : this.poseManager.vrTransforms.rightHand; + this.leftHand.reference = this.poseManager.vrTransforms.leftHand; + this.rightHand.reference = this.poseManager.vrTransforms.rightHand; } } diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 36a9fd8..0f74cfa 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -4,12 +4,11 @@ import {Transform, XRSettings} from './Unity.js'; class PoseManager { - constructor() { + constructor(rig) { this.transform = new Transform(); this.vrTransforms = new VRTrackingReferences(); - this.avatarVrTransforms = new AvatarVRTrackingReferences(); - this.avatarVrTransforms.poseManager = this; + this.avatarVrTransforms = new AvatarVRTrackingReferences(this); // this.OnCalibrateListener = null; // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. @@ -48,8 +47,6 @@ class PoseManager } const device = XRSettings.loadedDeviceName; this.vrSystemOffsetHeight = /*string.IsNullOrEmpty(device) || */device == "OpenVR" ? 0 : this.playerHeightHmd; - - this.avatarVrTransforms.Awake(); } /* Start() diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index a1705b8..d6e3cc9 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -566,10 +566,11 @@ class Rig { }; const rigObject = this.unity.makeGameObject('rig'); - this.poseManager = new PoseManager(); + this.poseManager = new PoseManager(this); this.poseManager.flipY = flipY; rigObject.components.set(PoseManager, this.poseManager); - this.shoulderTransforms = rigObject.AddComponent(ShoulderTransforms); + this.shoulderTransforms = new ShoulderTransforms(this); + rigObject.components.set(ShoulderTransforms, this.shoulderTransforms); this.legsManager = new LegsManager(this); rigObject.components.set(LegsManager, this.legsManager); diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index e8fcb04..86571b8 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion, Transform, GameObject, MonoBehavior, Mathf} from './Unity.js'; +import {Vector3, Quaternion, Transform, GameObject, Mathf} from './Unity.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import VRTrackingReferences from './VRTrackingReferences.js'; import PoseManager from './PoseManager.js'; @@ -6,12 +6,10 @@ import VectorHelpers from './Utils/VectorHelpers.js'; const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); -class ShoulderPoser extends MonoBehavior +class ShoulderPoser { - constructor(...args) { - super(...args); - - this.shoulder = this.GetComponent(ShoulderTransforms); + constructor(rig, shoulder) { + this.shoulder = shoulder; this.vrTrackingReferences = null; this.avatarTrackingReferences = null; @@ -54,7 +52,7 @@ class ShoulderPoser extends MonoBehavior this.leftShoulderAnkerStartLocalPosition = new Vector3(); this.rightShoulderAnkerStartLocalPosition = new Vector3(); - this.poseManager = this.GetOrAddComponent(PoseManager); + this.poseManager = rig.poseManager; if (this.vrTrackingReferences === null) this.vrTrackingReferences = this.poseManager.vrTransforms; if (this.avatarTrackingReferences === null) diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 4200ef2..dc53722 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -1,15 +1,14 @@ -import {Vector3, Transform, GameObject, MonoBehavior} from './Unity.js'; +import {Vector3, Transform} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; import VRArmIK from './VRArmIK.js'; import PoseManager from './PoseManager.js'; -class ShoulderTransforms extends MonoBehavior +class ShoulderTransforms { - constructor(transform, components, unity) { - super(transform, components, unity); - + constructor(rig) { + this.transform = new Transform(); this.hips = new Transform(); this.spine = new Transform(); this.neck = new Transform(); @@ -34,40 +33,49 @@ class ShoulderTransforms extends MonoBehavior this.rightShoulderAnchor = new Transform(); this.transform.AddChild(this.rightShoulderAnchor); - const poseManager = this.GetOrAddComponent(PoseManager); - this.leftArm = unity.makeGameObject().AddComponent(ArmTransforms); - this.leftArm.poseManager = poseManager; - this.rightArm = unity.makeGameObject().AddComponent(ArmTransforms); - this.rightArm.poseManager = poseManager; + this.leftArm = new ArmTransforms(); + this.leftArm.poseManager = rig.poseManager; + this.rightArm = new ArmTransforms(); + this.rightArm.poseManager = rig.poseManager; this.leftShoulderAnchor.AddChild(this.leftArm.transform); this.rightShoulderAnchor.AddChild(this.rightArm.transform); + + this.shoulderPoser = new ShoulderPoser(rig, this); + + this.leftArmIk = new VRArmIK(this.leftArm); + this.leftArmIk.shoulder = this; + this.leftArmIk.shoulderPoser = this.shoulderPoser; + this.leftArmIk.target = this.leftArmIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; + + this.rightArmIk = new VRArmIK(this.rightArm); + this.rightArmIk.shoulder = this; + this.rightArmIk.shoulderPoser = this.shoulderPoser; + this.rightArmIk.target = this.rightArmIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; + this.rightArmIk.left = false; } - OnEnable() + Start() { - const shoulderPoser = this.GetComponent(ShoulderPoser); - { - const armIk = this.leftArm.GetComponentInChildren(VRArmIK); - armIk.shoulder = this; - armIk.shoulderPoser = shoulderPoser; - armIk.target = armIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; - } - { - const armIk = this.rightArm.GetComponentInChildren(VRArmIK); - armIk.shoulder = this; - armIk.shoulderPoser = shoulderPoser; - armIk.target = armIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; - armIk.left = false; - } + // this.setShoulderWidth(PoseManager.Instance.playerWidthShoulders); + + this.leftArm.Start(); + this.rightArm.Start(); + this.shoulderPoser.Start(); + this.leftArmIk.Start(); + this.rightArmIk.Start(); } - /* Start() - { - this.setShoulderWidth(PoseManager.Instance.playerWidthShoulders); + Update() { + this.shoulderPoser.Update(); + } + + LateUpdate() { + this.leftArmIk.LateUpdate(); + this.rightArmIk.LateUpdate(); } - setShoulderWidth(width) + /* setShoulderWidth(width) { const localScale = new Vector3(width * .5, .05, .05); const localPosition = new Vector3(width * .25, 0, 0); diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js index b094ca7..d278e7e 100644 --- a/vrarmik/StaticOffsetTransform.js +++ b/vrarmik/StaticOffsetTransform.js @@ -53,10 +53,10 @@ class StaticOffsetTransform } } - Awake() + /* Awake() { this.updatePosition(); - } + } */ Update() { diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index f293c75..e7a6377 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -75,12 +75,10 @@ function toPositiveEulerAngle(n) return result; } - class VRArmIK extends MonoBehavior + class VRArmIK { - constructor(...args) { - super(...args); - - this.arm = this.GetOrAddComponent(ArmTransforms); + constructor(arm) { + this.arm = arm; this.shoulder = null; this.shoulderPoser = null; this.target = new Transform(); @@ -102,7 +100,7 @@ function toPositiveEulerAngle(n) this.interpolatedDeltaElbowForward = 0; } - Awake() + Start() { this.upperArmStartRotation = this.arm.upperArm.rotation; this.lowerArmStartRotation = this.arm.lowerArm.rotation; @@ -110,10 +108,7 @@ function toPositiveEulerAngle(n) if (this.arm.wrist1 !== null) this.wristStartRotation = this.arm.wrist1.rotation; this.handStartRotation = this.arm.hand.rotation; - } - OnEnable() - { this.setUpperArmRotation(Quaternion.identity); this.setLowerArmRotation(Quaternion.identity); this.setHandRotation(Quaternion.identity); From 32f5fa3f564c9be1a71b301455124acbc17ca8fe Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 00:33:32 -0400 Subject: [PATCH 345/562] VRArmIK dead update code cleanup --- vrarmik/ShoulderTransforms.js | 7 ++----- vrarmik/VRArmIK.js | 2 +- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index dc53722..9686d5c 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -68,11 +68,8 @@ class ShoulderTransforms Update() { this.shoulderPoser.Update(); - } - - LateUpdate() { - this.leftArmIk.LateUpdate(); - this.rightArmIk.LateUpdate(); + this.leftArmIk.Update(); + this.rightArmIk.Update(); } /* setShoulderWidth(width) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index e7a6377..1b61699 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -114,7 +114,7 @@ function toPositiveEulerAngle(n) this.setHandRotation(Quaternion.identity); } - LateUpdate() + Update() { this.updateUpperArmPosition(); this.calcElbowInnerAngle(); From 5ec6f759ad0c113a6e17d771579e4cd77ce47b21 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 00:35:03 -0400 Subject: [PATCH 346/562] More dead code cleanup --- vrarmik/VRArmIK.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 1b61699..2bf9110 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion, Transform, GameObject, MonoBehavior, Time, Mathf} from './Unity.js'; +import {Vector3, Quaternion, Transform, GameObject, Time, Mathf} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; import VectorHelpers from './Utils/VectorHelpers.js'; From dd591b5dfb6300dc6b84bc26d691d543cc3cfc32 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 00:46:35 -0400 Subject: [PATCH 347/562] Remove unity engine instantiation for rig --- vrarmik/LegsManager.js | 8 ++++---- vrarmik/PoseManager.js | 2 +- vrarmik/Rig.js | 18 ++++++++---------- 3 files changed, 13 insertions(+), 15 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 26e109f..d2898a3 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -35,7 +35,7 @@ class Leg { this.lowerLegLength = this.foot.localPosition.length(); } - LateUpdate() { + Update() { // const hipsDirection = new Vector3(0, 0, 1).applyQuaternion(this.transform.rotation); // const hipsY = Math.atan2(hipsDirection.z, hipsDirection.x); /* if (hipsY > Math.PI) { @@ -192,7 +192,7 @@ class LegsManager { this.rightLeg.Start(); } - LateUpdate() { + Update() { const hipsFloorPosition = this.hips.position; hipsFloorPosition.y = 0; const hipsFloorEuler = new THREE.Euler().setFromQuaternion(this.hips.rotation, 'YXZ'); @@ -283,8 +283,8 @@ class LegsManager { this.rightLeg.foot.stickTransform.position = footPosition; } - this.leftLeg.LateUpdate(); - this.rightLeg.LateUpdate(); + this.leftLeg.Update(); + this.rightLeg.Update(); } } diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 0f74cfa..e39940b 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -39,7 +39,7 @@ class PoseManager } } */ - Awake() + Start() { if (this.loadPlayerSizeOnAwake) { diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index d6e3cc9..746e221 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -1,4 +1,4 @@ -import {Vector3, Quaternion, Unity} from './Unity.js'; +import {Vector3, Quaternion} from './Unity.js'; import {fixSkeletonZForward} from '../proto/three-ik/modified.AxisUtils.js'; import PoseManager from './PoseManager.js'; import ShoulderTransforms from './ShoulderTransforms.js'; @@ -47,9 +47,6 @@ class Rig { this.model = model; this.options = options; - const unity = new Unity(); - this.unity = unity; - model.updateMatrixWorld(true); const skinnedMeshes = []; model.traverse(o => { @@ -565,14 +562,10 @@ class Rig { rightFoot: _getOffset(modelBones.Left_ankle), }; - const rigObject = this.unity.makeGameObject('rig'); this.poseManager = new PoseManager(this); this.poseManager.flipY = flipY; - rigObject.components.set(PoseManager, this.poseManager); this.shoulderTransforms = new ShoulderTransforms(this); - rigObject.components.set(ShoulderTransforms, this.shoulderTransforms); this.legsManager = new LegsManager(this); - rigObject.components.set(LegsManager, this.legsManager); this.shoulderTransforms.spine.localPosition = setups.spine; this.shoulderTransforms.transform.localPosition = setups.chest; @@ -662,11 +655,16 @@ class Rig { this.lastTimestamp = Date.now(); - unity.startAll(); + this.poseManager.Start(); + this.shoulderTransforms.Start(); + this.legsManager.Start(); } update() { // return; - this.unity.updateAll(); + + this.poseManager.Update(); + this.shoulderTransforms.Update(); + this.legsManager.Update(); for (const k in this.modelBones) { const modelBone = this.modelBones[k]; From 6935712a44c2f3944e09d3beac706e8c295eccd1 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 00:46:49 -0400 Subject: [PATCH 348/562] Comment out dead unity engine implementation --- vrarmik/Unity.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 09ef38b..630b73d 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -487,7 +487,7 @@ const XRSettings = { loadedDeviceName: 'OpenVR', }; -class Unity { +/* class Unity { constructor() { this.gameObjects = []; } @@ -530,7 +530,7 @@ class Unity { }); } } -} +} */ export { Vector2, @@ -543,5 +543,5 @@ export { Mathf, PlayerPrefs, XRSettings, - Unity, + // Unity, }; From f347140bfbd3439c9b85f6d1ba4acbb434d9de88 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 01:24:57 -0400 Subject: [PATCH 349/562] Remove dead avatar tracking references code --- vrarmik/AvatarVRTrackingReferences.js | 88 +-------------------------- vrarmik/PoseManager.js | 4 -- vrarmik/Rig.js | 1 - vrarmik/ShoulderPoser.js | 24 ++++---- vrarmik/ShoulderTransforms.js | 4 +- 5 files changed, 17 insertions(+), 104 deletions(-) diff --git a/vrarmik/AvatarVRTrackingReferences.js b/vrarmik/AvatarVRTrackingReferences.js index e757c8b..5f40f4f 100644 --- a/vrarmik/AvatarVRTrackingReferences.js +++ b/vrarmik/AvatarVRTrackingReferences.js @@ -1,93 +1,11 @@ import {Vector3, Transform} from './Unity.js'; -import StaticOffsetTransform from './StaticOffsetTransform.js'; - class AvatarVRTrackingReferences { constructor(poseManager) { - this.transform = new Transform(); - - this.head = null; - this.leftHand = null; - this.rightHand = null; - // this.hmd = null; - - this.poseManager = poseManager; - - this.initTransforms(); - } - - /* Awake() - { - this.initTransforms(); - - this.head.Awake(); - this.leftHand.Awake(); - this.rightHand.Awake(); - } */ - - Update() { - this.head.Update(); - this.leftHand.Update(); - this.rightHand.Update(); - } - - initTransforms() - { - this.createTransforms(); - this.connectTransforms(); - } - - setStaticOffsetSettings(s) - { - s.referenceLocalPosition = false; - s.referenceLocalRotation = false; - s.applyLocalPosition = true; - s.applyLocalRotation = true; - s.applyPosition = true; - s.applyRotation = true; - s.applyForwardOffsetAfterRotationOffset = false; - } - - - createTransform(k) - { - const t = new StaticOffsetTransform(); - this.transform.AddChild(t.transform); - this.setStaticOffsetSettings(t); - this[k] = t; - } - - /* createHandTransform(t, name, parent) - { - if (t === null) - { - t = this.unity.makeGameObject(name).transform; - t.transform.localPosition = Vector3.zero; - this.transform.AddChild(t.transform); - } - } */ - - createTransforms() - { - this.createTransform('head'); - this.createTransform('leftHand'); - this.createTransform('rightHand'); - // this.createTransform('hmd'); - } - - connectTransforms() - { - /* const sot = this.GetOrAddComponent(StaticOffsetTransform); - if (sot.reference === null) - { - sot.reference = this.transform.parent; - } */ - - this.head.reference = this.poseManager.vrTransforms.head; - // this.hmd.reference = this.hmd.reference !== null ? this.hmd.reference : this.poseManager.vrTransforms.hmd; - this.leftHand.reference = this.poseManager.vrTransforms.leftHand; - this.rightHand.reference = this.poseManager.vrTransforms.rightHand; + this.head = poseManager.vrTransforms.head; + this.leftHand = poseManager.vrTransforms.leftHand; + this.rightHand = poseManager.vrTransforms.rightHand; } } diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index e39940b..755ce75 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -59,10 +59,6 @@ class PoseManager this.playerHeightHmd = Camera.main.transform.position.y; } */ - Update() { - this.avatarVrTransforms.Update(); - } - loadPlayerWidthShoulders() { this.playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31); diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 746e221..dea7dda 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -662,7 +662,6 @@ class Rig { update() { // return; - this.poseManager.Update(); this.shoulderTransforms.Update(); this.legsManager.Update(); diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 86571b8..134e07e 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -67,9 +67,9 @@ class ShoulderPoser /* onCalibrate() { - this.shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.transform.position - this.shoulder.leftShoulderAnchor.position) + this.shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.position - this.shoulder.leftShoulderAnchor.position) .magnitude); - this.shoulder.rightArm.setArmLength((avatarTrackingReferences.rightHand.transform.position - this.shoulder.rightShoulderAnchor.position) + this.shoulder.rightArm.setArmLength((avatarTrackingReferences.rightHand.position - this.shoulder.rightShoulderAnchor.position) .magnitude); } */ @@ -139,14 +139,14 @@ class ShoulderPoser rotateLeftShoulder() { - this.rotateShoulderUp(this.shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand.transform, + this.rotateShoulderUp(this.shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand, this.leftShoulderAnkerStartLocalPosition, 1); } rotateRightShoulder() { - this.rotateShoulderUp(this.shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand.transform, + this.rotateShoulderUp(this.shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand, this.rightShoulderAnkerStartLocalPosition, -1); } @@ -181,8 +181,8 @@ class ShoulderPoser positionShoulder() { - /* const headNeckOffset = this.headNeckDirectionVector.clone().applyQuaternion(this.avatarTrackingReferences.head.transform.rotation); - const targetPosition = new Vector3().addVectors(this.avatarTrackingReferences.head.transform.position, headNeckOffset.clone().multiplyScalar(this.headNeckDistance)); + /* const headNeckOffset = this.headNeckDirectionVector.clone().applyQuaternion(this.avatarTrackingReferences.head.rotation); + const targetPosition = new Vector3().addVectors(this.avatarTrackingReferences.head.position, headNeckOffset.clone().multiplyScalar(this.headNeckDistance)); this.shoulder.transform.localPosition = new Vector3().addVectors(targetPosition, this.neckShoulderDistance); */ } @@ -233,14 +233,14 @@ class ShoulderPoser positionShoulderRelative() { const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right); - const shoulderHeadDiff = new Vector3().subVectors(this.shoulder.transform.position, this.avatarTrackingReferences.head.transform.position); - // this.shoulder.transform.position = new Vector3().addVectors(shoulderHeadDiff.clone().applyQuaternion(deltaRot), this.avatarTrackingReferences.head.transform.position); + const shoulderHeadDiff = new Vector3().subVectors(this.shoulder.transform.position, this.avatarTrackingReferences.head.position); + // this.shoulder.transform.position = new Vector3().addVectors(shoulderHeadDiff.clone().applyQuaternion(deltaRot), this.avatarTrackingReferences.head.position); } getCombinedDirectionAngleUp() { - const leftHand = this.avatarTrackingReferences.leftHand.transform; - const rightHand = this.avatarTrackingReferences.rightHand.transform; + const leftHand = this.avatarTrackingReferences.leftHand; + const rightHand = this.avatarTrackingReferences.rightHand; const distanceLeftHand = new Vector3().subVectors(leftHand.position, this.shoulder.transform.position); const distanceRightHand = new Vector3().subVectors(rightHand.position, this.shoulder.transform.position); @@ -339,8 +339,8 @@ class ShoulderPoser clampShoulderHandDistance() { - const leftHandVector = new Vector3().subVectors(this.avatarTrackingReferences.leftHand.transform.position, this.shoulder.leftShoulderAnchor.position); - const rightHandVector = new Vector3().subVectors(this.avatarTrackingReferences.rightHand.transform.position, this.shoulder.rightShoulderAnchor.position); + const leftHandVector = new Vector3().subVectors(this.avatarTrackingReferences.leftHand.position, this.shoulder.leftShoulderAnchor.position); + const rightHandVector = new Vector3().subVectors(this.avatarTrackingReferences.rightHand.position, this.shoulder.rightShoulderAnchor.position); const leftShoulderHandDistance = leftHandVector.magnitude; const rightShoulderHandDistance = rightHandVector.magnitude; this.shoulderDislocated = false; diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 9686d5c..155de2a 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -46,12 +46,12 @@ class ShoulderTransforms this.leftArmIk = new VRArmIK(this.leftArm); this.leftArmIk.shoulder = this; this.leftArmIk.shoulderPoser = this.shoulderPoser; - this.leftArmIk.target = this.leftArmIk.shoulderPoser.avatarTrackingReferences.leftHand.transform; + this.leftArmIk.target = this.leftArmIk.shoulderPoser.avatarTrackingReferences.leftHand; this.rightArmIk = new VRArmIK(this.rightArm); this.rightArmIk.shoulder = this; this.rightArmIk.shoulderPoser = this.shoulderPoser; - this.rightArmIk.target = this.rightArmIk.shoulderPoser.avatarTrackingReferences.rightHand.transform; + this.rightArmIk.target = this.rightArmIk.shoulderPoser.avatarTrackingReferences.rightHand; this.rightArmIk.left = false; } From b7b446a9dac836c5ebe50c8cd810a78f289882ae Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 02:06:51 -0400 Subject: [PATCH 350/562] Small dead code cleanup --- vrarmik/ShoulderPoser.js | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 134e07e..f623f4d 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -77,8 +77,8 @@ class ShoulderPoser { this.updateHips(); - this.shoulder.transform.rotation = Quaternion.identity; - this.positionShoulder(); + // this.shoulder.transform.rotation = Quaternion.identity; + // this.positionShoulder(); this.rotateShoulderUpBase(); this.rotateShoulderRightBase(); @@ -227,15 +227,15 @@ class ShoulderPoser this.shoulder.transform.rotation = new Quaternion().multiplyQuaternions(deltaRot, this.shoulder.transform.rotation); - this.positionShoulderRelative(); + // this.positionShoulderRelative(); } - positionShoulderRelative() + /* positionShoulderRelative() { const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right); const shoulderHeadDiff = new Vector3().subVectors(this.shoulder.transform.position, this.avatarTrackingReferences.head.position); // this.shoulder.transform.position = new Vector3().addVectors(shoulderHeadDiff.clone().applyQuaternion(deltaRot), this.avatarTrackingReferences.head.position); - } + } */ getCombinedDirectionAngleUp() { @@ -296,7 +296,7 @@ class ShoulderPoser return Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180 / Mathf.PI; } - detectHandsBehindHead(targetRotation) + /* detectHandsBehindHead(targetRotation) { const delta = Mathf.Abs(targetRotation.y - this.lastAngle.y + 360) % 360; if (delta > 150 && delta < 210 && this.lastAngle.magnitude > 0.000001 && !this.clampingHeadRotation) @@ -310,7 +310,7 @@ class ShoulderPoser { targetRotation.y += 180; } - } + } */ clampHeadRotationDeltaUp(targetRotation) { From 1d04c2c16d14aec17e0b10acab4ad03290f90d32 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 02:09:03 -0400 Subject: [PATCH 351/562] Small hips rotation code cleanup --- vrarmik/ShoulderPoser.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index f623f4d..c346e91 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -118,8 +118,8 @@ class ShoulderPoser const spinePosition = chestPosition.clone().add(this.shoulder.transform.localPosition.multiplyScalar(-1).applyQuaternion(hmdFlatRotation)); const hipsPosition = spinePosition.clone().add(this.shoulder.spine.localPosition.multiplyScalar(-1).applyQuaternion(hmdFlatRotation)); - this.shoulder.hips.position = hipsPosition; - this.shoulder.hips.rotation = hmdFlatRotation; + this.shoulder.hips.localPosition = hipsPosition; + this.shoulder.hips.localRotation = hmdFlatRotation; this.shoulder.spine.rotation = hmdFlatRotation; this.shoulder.transform.localRotation = new Quaternion(); } From f4913a103dd2f79f3906ecfc7b267b81611c17b2 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 02:10:45 -0400 Subject: [PATCH 352/562] More rotation code cleanup --- vrarmik/ShoulderPoser.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index c346e91..678b70f 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -120,8 +120,8 @@ class ShoulderPoser this.shoulder.hips.localPosition = hipsPosition; this.shoulder.hips.localRotation = hmdFlatRotation; - this.shoulder.spine.rotation = hmdFlatRotation; - this.shoulder.transform.localRotation = new Quaternion(); + // this.shoulder.spine.rotation = hmdFlatRotation; + // this.shoulder.transform.localRotation = new Quaternion(); } updateNeck() { From 48cad11d23afcffaa5408612ac047f2a940274b8 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 02:21:12 -0400 Subject: [PATCH 353/562] Shoulder rotations cleanup --- vrarmik.html | 1 + vrarmik/ShoulderPoser.js | 31 ++++++++++++++----------------- 2 files changed, 15 insertions(+), 17 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 50aaf5b..589546a 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -861,6 +861,7 @@

Multiplayer

// rig.inputs.hmd.position = new Vector3(positionOffset, 0.6 + standFactor, 0); rig.inputs.hmd.position = new Vector3(positionOffset, standFactor, 0); rig.inputs.hmd.rotation = new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle) + .multiply(new Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.2)) .multiply(new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.25)); rig.inputs.rightGamepad.rotation = new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle); diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 678b70f..19a9cc5 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -10,8 +10,9 @@ class ShoulderPoser { constructor(rig, shoulder) { this.shoulder = shoulder; - this.vrTrackingReferences = null; - this.avatarTrackingReferences = null; + this.poseManager = rig.poseManager; + this.vrTrackingReferences = this.poseManager.vrTransforms; + this.avatarTrackingReferences = this.poseManager.avatarVrTransforms; // this.headNeckDirectionVector = new Vector3(1.0894440904962721e-10, -0.06860782711996793, -0.0006757629250115499).normalize(); // this.headNeckDistance = 0.06861115505261682; @@ -46,17 +47,10 @@ class ShoulderPoser this.shoulderDislocated = false; this.shoulderRightRotation; - - this.lastAngle = Vector3.zero; + // this.lastAngle = Vector3.zero; this.leftShoulderAnkerStartLocalPosition = new Vector3(); this.rightShoulderAnkerStartLocalPosition = new Vector3(); - - this.poseManager = rig.poseManager; - if (this.vrTrackingReferences === null) - this.vrTrackingReferences = this.poseManager.vrTransforms; - if (this.avatarTrackingReferences === null) - this.avatarTrackingReferences = this.poseManager.avatarVrTransforms; } Start() { @@ -128,13 +122,16 @@ class ShoulderPoser // const hmdPosition = this.vrTrackingReferences.head.position; const hmdRotation = this.vrTrackingReferences.head.rotation; hmdRotation.multiply(z180Quaternion); - const hmdEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); - hmdEuler.x = 0; - hmdEuler.z = 0; - const hmdFlatRotation = new Quaternion().setFromEuler(hmdEuler); - - this.shoulder.neck.rotation = hmdFlatRotation; - this.shoulder.head.rotation = hmdRotation; + const hmdFlatEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); + hmdFlatEuler.x = 0; + hmdFlatEuler.z = 0; + const hmdFlatRotation = new Quaternion().setFromEuler(hmdFlatEuler); + const hmdUpEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); + hmdUpEuler.y = 0; + const hmdUpRotation = new Quaternion().setFromEuler(hmdUpEuler); + + this.shoulder.neck.localRotation = hmdFlatRotation.clone().premultiply(this.shoulder.transform.rotation.inverse()); + this.shoulder.head.localRotation = hmdUpRotation; } rotateLeftShoulder() From 74752c53d29283a19d57a27c6680ef9f6aa294ec Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 02:22:57 -0400 Subject: [PATCH 354/562] Clean up wrist rotation computation --- vrarmik/VRArmIK.js | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 2bf9110..6f7fbf6 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -47,7 +47,7 @@ class ElbowCorrectionSettings class HandSettings { constructor() { - this.useWristRotation = true; + // this.useWristRotation = true; this.rotateElbowWithHandRight = true; this.rotateElbowWithHandForward = true; this.handDeltaPow = 1.5; @@ -93,7 +93,7 @@ function toPositiveEulerAngle(n) this.upperArmStartRotation = new Quaternion(); this.lowerArmStartRotation = new Quaternion(); - this.wristStartRotation = new Quaternion(); + // this.wristStartRotation = new Quaternion(); this.handStartRotation = new Quaternion(); this.interpolatedDeltaElbow = 0; @@ -104,9 +104,9 @@ function toPositiveEulerAngle(n) { this.upperArmStartRotation = this.arm.upperArm.rotation; this.lowerArmStartRotation = this.arm.lowerArm.rotation; - this.wristStartRotation = Quaternion.identity; + /* this.wristStartRotation = Quaternion.identity; if (this.arm.wrist1 !== null) - this.wristStartRotation = this.arm.wrist1.rotation; + this.wristStartRotation = this.arm.wrist1.rotation; */ this.handStartRotation = this.arm.hand.rotation; this.setUpperArmRotation(Quaternion.identity); @@ -368,7 +368,7 @@ function toPositiveEulerAngle(n) rotateHand() { - if (this.handSettings.useWristRotation) + /* if (this.handSettings.useWristRotation) { let handUpVec = Vector3.up.applyQuaternion(this.target.rotation); const forwardAngle = VectorHelpers.getAngleBetween(Vector3.right.applyQuaternion(this.lowerArmRotation), Vector3.right.applyQuaternion(this.target.rotation), @@ -386,7 +386,7 @@ function toPositiveEulerAngle(n) this.setWrist1Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .3, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); if (this.arm.wrist2 !== null) this.setWrist2Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .8, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); - } + } */ const targetRotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); this.setHandRotation(targetRotation); } @@ -430,7 +430,7 @@ function toPositiveEulerAngle(n) setLowerArmLocalRotation(rotation) { return this.arm.lowerArm.rotation = new Quaternion().multiplyQuaternions(new Quaternion().multiplyQuaternions(this.upperArmRotation, rotation), this.lowerArmStartRotation); } - setWrist1Rotation(rotation) { + /* setWrist1Rotation(rotation) { return this.arm.wrist1.rotation = new Quaternion().multiplyQuaternions(rotation, this.wristStartRotation); } setWrist2Rotation(rotation) { @@ -438,7 +438,7 @@ function toPositiveEulerAngle(n) } setWristLocalRotation(rotation) { return this.arm.wrist1.rotation = new Quaternion().multiplyQuaternions(new Quaternion().multiplyQuaternions(this.arm.lowerArm.rotation, rotation), this.wristStartRotation); - } + } */ setHandRotation(rotation) { return this.arm.hand.rotation = /* this.arm.hand.rotation = */ new Quaternion().multiplyQuaternions(rotation, this.handStartRotation); } From a3dd3ab69c72a315388431367fcea54391dcdd71 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 02:24:13 -0400 Subject: [PATCH 355/562] More dead code cleanup --- vrarmik/VRArmIK.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 6f7fbf6..f71535a 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -116,7 +116,7 @@ function toPositiveEulerAngle(n) Update() { - this.updateUpperArmPosition(); + // this.updateUpperArmPosition(); this.calcElbowInnerAngle(); this.rotateShoulder(); this.correctElbowRotation(); @@ -134,9 +134,9 @@ function toPositiveEulerAngle(n) } } - updateArmAndTurnElbowUp() + /* updateArmAndTurnElbowUp() { - this.updateUpperArmPosition(); + // this.updateUpperArmPosition(); this.calcElbowInnerAngle(); this.rotateShoulder(); this.correctElbowRotation(); @@ -145,7 +145,7 @@ function toPositiveEulerAngle(n) updateUpperArmPosition() { //this.arm.upperArm.position = this.shoulderAnker.position; - } + } */ calcElbowInnerAngle() { From 2d3a2b003f58babf591f7e288d125a4366b8c993 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 21:47:51 -0400 Subject: [PATCH 356/562] Disable shoulder dislocation --- vrarmik/ShoulderPoser.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 19a9cc5..b0c28a4 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -82,7 +82,7 @@ class ShoulderPoser this.rotateRightShoulder(); } - if (this.enableShoulderDislocation) + /* if (this.enableShoulderDislocation) { this.clampShoulderHandDistance(); } @@ -90,7 +90,7 @@ class ShoulderPoser { this.shoulder.leftArm.transform.localPosition = Vector3.zero; this.shoulder.rightArm.transform.localPosition = Vector3.zero; - } + } */ this.updateNeck(); From 735e4a5ec69602e3ab0aa65e3e2305fabb6b524b Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 21:48:25 -0400 Subject: [PATCH 357/562] Small gamepads cleanup --- vrarmik.html | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 589546a..a7f68d7 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -819,7 +819,7 @@

Multiplayer

} }; - const lg = _getGamepad(0); + const lg = _getGamepad(1); let li = -1; if (lg) { const {position, rotation, pressed, lastPressed} = lg; @@ -834,7 +834,7 @@

Multiplayer

lastPresseds[0] = pressed; } - const rg = _getGamepad(1); + const rg = _getGamepad(0); let ri = -1; if (rg) { const {position, rotation, pressed, lastPressed} = rg; From 16a9132bfcb41e4fd206a2eef459d71e406aac29 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 21:52:43 -0400 Subject: [PATCH 358/562] Majro VRArmIK rewrite --- vrarmik/VRArmIK.js | 104 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 89 insertions(+), 15 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index f71535a..f7a395d 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -104,6 +104,9 @@ function toPositiveEulerAngle(n) { this.upperArmStartRotation = this.arm.upperArm.rotation; this.lowerArmStartRotation = this.arm.lowerArm.rotation; + this.upperArmLength = this.arm.lowerArm.position.distanceTo(this.arm.upperArm.position); + this.lowerArmLength = this.arm.hand.position.distanceTo(this.arm.lowerArm.position); + this.armLength = this.upperArmLength + this.lowerArmLength; /* this.wristStartRotation = Quaternion.identity; if (this.arm.wrist1 !== null) this.wristStartRotation = this.arm.wrist1.rotation; */ @@ -116,22 +119,93 @@ function toPositiveEulerAngle(n) Update() { - // this.updateUpperArmPosition(); - this.calcElbowInnerAngle(); - this.rotateShoulder(); - this.correctElbowRotation(); + // const targetPosition = this.target.position; + // const targetRotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); + + const handPositionDistance = this.target.position.distanceTo(this.arm.upperArm.position); + let handPosition; + // if (handPositionDistance < this.armLength) { + handPosition = this.target.position; + /* } else { + handPosition = this.arm.upperArm.position.add( + this.target.position.sub(this.arm.upperArm.position).normalize().multiplyScalar(this.armLength) + ); + } */ + + const shoulderRotation = this.shoulder.transform.rotation; + const shoulderRotationInverse = shoulderRotation.clone().inverse(); + + const hypotenuseDistance = this.upperArmLength; + const directDistance = this.arm.upperArm.position.distanceTo(handPosition) / 2; + /* if (this.left) { + console.log('distances', hypotenuseDistance, directDistance); + } */ + const offsetDistance = hypotenuseDistance > directDistance ? Math.sqrt(hypotenuseDistance*hypotenuseDistance - directDistance*directDistance) : 0; + // console.log('offset distance', this.upperArmLength, this.lowerArmLength, hypotenuseDistance, directDistance, offsetDistance); + // const outFactor = targetEuler.x < 0 ? (1 - Math.min(Math.max(-targetEuler.x/(Math.PI/4), 0), 1)) : 1; + const offsetDirection = handPosition.clone().sub(this.arm.upperArm.position).normalize() + .cross( + new Vector3(-1, 0, 0) + .applyQuaternion(shoulderRotation/*.clone().premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? 1 : -1) * Math.PI*0.1))*/) + ); + //.applyQuaternion(shoulderRotation.clone().multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)))) + // .normalize(); + + const localOffsetDirection = offsetDirection.clone().applyQuaternion(shoulderRotationInverse); + const targetLocalRotation = this.target.rotation.multiply(shoulderRotationInverse).premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); + const targetEuler = new THREE.Euler().setFromQuaternion( + targetLocalRotation, + 'XYZ' + ); + const targetDirection = new Vector3(0, 0, 1).applyQuaternion(targetLocalRotation); + if (this.left) { + const yFactor = Math.min(Math.max((targetEuler.y+Math.PI*0.1)/(Math.PI/2), 0), 1); + // const zFactor = Math.min(Math.max((-targetDirection.x + 0.5)/0.25, 0), 1) + // const xFactor = Math.min(Math.max((targetDirection.y-0.8)/0.2, 0), 1); + // yFactor *= 1-xFactor; + // const factor = Math.min(yFactor, 1-xFactor);//Math.min(yFactor, 1-xFactor); + targetEuler.z = Math.min(Math.max(targetEuler.z, -Math.PI/2), 0); + targetEuler.z = (targetEuler.z * (1 - yFactor)) + (-Math.PI/2 * yFactor); + // targetEuler.z *= 1 - xFactor; + // targetEuler.z *= 1 - zFactor; + } else { + const yFactor = Math.min(Math.max((-targetEuler.y-Math.PI*0.1)/(Math.PI/2), 0), 1); + // const zFactor = Math.min(Math.max((-targetDirection.x + 0.5)/0.25, 0), 1) + // const xFactor = Math.min(Math.max((targetDirection.y-0.8)/0.2, 0), 1); + // yFactor *= 1-xFactor; + // const factor = Math.min(yFactor, 1-xFactor);//Math.min(yFactor, 1-xFactor); + targetEuler.z = Math.min(Math.max(targetEuler.z, 0), Math.PI/2); + targetEuler.z = (targetEuler.z * (1 - yFactor)) + (Math.PI/2 * yFactor); + // targetEuler.z *= 1 - xFactor; + // targetEuler.z *= 1 - zFactor; + } + // targetEuler.y = 0; + // targetEuler.x = 0; + localOffsetDirection.applyAxisAngle(new Vector3(0, 0, 1), targetEuler.z); + offsetDirection.copy(localOffsetDirection).applyQuaternion(this.shoulder.transform.rotation); + + const elbowPosition = this.arm.upperArm.position.add(handPosition).divideScalar(2) + .add(offsetDirection.clone().multiplyScalar(offsetDistance)); + + this.arm.upperArm.rotation = new Quaternion().setFromRotationMatrix( + new THREE.Matrix4().lookAt( + new Vector3(), + elbowPosition.clone().sub(this.arm.upperArm.position), + new Vector3(this.left ? -1 : 1, 0, 0).applyQuaternion(shoulderRotation) + ) + ).multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.left ? -1 : 1) * Math.PI/2)); - if (this.elbowSettings.calcElbowAngle) - { - this.positionElbow(); - /* if (this.elbowCorrectionSettings.useFixedElbowWhenNearShoulder) - this.correctElbowAfterPositioning(); */ - if (this.handSettings.rotateElbowWithHandRight) - this.rotateElbowWithHandRight(); - if (this.handSettings.rotateElbowWithHandForward) - this.rotateElbowWithHandFoward(); - this.rotateHand(); - } + // this.arm.lowerArm.position = elbowPosition; + this.arm.lowerArm.rotation = new Quaternion().setFromRotationMatrix( + new THREE.Matrix4().lookAt( + new Vector3(), + handPosition.clone().sub(elbowPosition), + new Vector3(this.left ? -1 : 1, 0, 0).applyQuaternion(shoulderRotation) + ) + ).multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.left ? -1 : 1) * Math.PI/2)); + + // this.arm.hand.position = handPosition; + this.arm.hand.rotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); } /* updateArmAndTurnElbowUp() From 17d41e250ff7c7cbec1a86f8ff87abe6c21d4559 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Tue, 29 Oct 2019 21:55:24 -0400 Subject: [PATCH 359/562] Major VRArmIK dead code cleanup --- vrarmik/VRArmIK.js | 404 --------------------------------------------- 1 file changed, 404 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index f7a395d..780eb3f 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -3,78 +3,6 @@ import ArmTransforms from './ArmTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; import VectorHelpers from './Utils/VectorHelpers.js'; -class ArmIKElbowSettings -{ - constructor() { - this.calcElbowAngle = true; - this.clampElbowAngle = true; - this.softClampElbowAngle = true; - this.maxAngle = 175; - this.minAngle = 13; - this.softClampRange = 10; - this.offsetAngle = 135; - this.yWeight = -60; - this.zWeightTop = 260; - this.zWeightBottom = -100; - this.zBorderY = -.25; - this.zDistanceStart = .6; - this.xWeight = -50; - this.xDistanceStart = .1; - } -} - -class BeforePositioningSettings -{ - constructor() { - this.correctElbowOutside = true; - this.weight = -0.5; - this.startBelowZ = .4; - this.startAboveY = 0.1; - } -} - -class ElbowCorrectionSettings -{ - constructor() { - this.useFixedElbowWhenNearShoulder = true; - this.startBelowDistance = .5; - this.startBelowY = 0.1; - this.weight = 2; - this.localElbowPos = new Vector3(0.3, -1, -2); - } -} - -class HandSettings -{ - constructor() { - // this.useWristRotation = true; - this.rotateElbowWithHandRight = true; - this.rotateElbowWithHandForward = true; - this.handDeltaPow = 1.5; - this.handDeltaFactor = -.3; - this.handDeltaOffset = 45; - // todo fix rotateElbowWithHandForward with factor != 1 -> horrible jumps. good value would be between [0.4, 0.6] - this.handDeltaForwardPow = 2; - this.handDeltaForwardFactor = 1; - this.handDeltaForwardOffset = 0; - this.handDeltaForwardDeadzone = .3; - this.rotateElbowWithHandDelay = .08; - } -} - -function toSignedEulerAngle(n) -{ - let result = toPositiveEulerAngle(n); - if (result > 180) - result = result - 360; - return result; -} -function toPositiveEulerAngle(n) -{ - const result = (n % 360 + 360) % 360; - return result; -} - class VRArmIK { constructor(arm) { @@ -83,21 +11,6 @@ function toPositiveEulerAngle(n) this.shoulderPoser = null; this.target = new Transform(); this.left = true; - - this.elbowSettings = new ArmIKElbowSettings(); - this.beforePositioningSettings = new BeforePositioningSettings(); - this.elbowCorrectionSettings = new ElbowCorrectionSettings(); - this.handSettings = new HandSettings(); - - this.nextLowerArmAngle = new Vector3(); - - this.upperArmStartRotation = new Quaternion(); - this.lowerArmStartRotation = new Quaternion(); - // this.wristStartRotation = new Quaternion(); - this.handStartRotation = new Quaternion(); - - this.interpolatedDeltaElbow = 0; - this.interpolatedDeltaElbowForward = 0; } Start() @@ -107,14 +20,6 @@ function toPositiveEulerAngle(n) this.upperArmLength = this.arm.lowerArm.position.distanceTo(this.arm.upperArm.position); this.lowerArmLength = this.arm.hand.position.distanceTo(this.arm.lowerArm.position); this.armLength = this.upperArmLength + this.lowerArmLength; - /* this.wristStartRotation = Quaternion.identity; - if (this.arm.wrist1 !== null) - this.wristStartRotation = this.arm.wrist1.rotation; */ - this.handStartRotation = this.arm.hand.rotation; - - this.setUpperArmRotation(Quaternion.identity); - this.setLowerArmRotation(Quaternion.identity); - this.setHandRotation(Quaternion.identity); } Update() @@ -207,315 +112,6 @@ function toPositiveEulerAngle(n) // this.arm.hand.position = handPosition; this.arm.hand.rotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); } - - /* updateArmAndTurnElbowUp() - { - // this.updateUpperArmPosition(); - this.calcElbowInnerAngle(); - this.rotateShoulder(); - this.correctElbowRotation(); - } - - updateUpperArmPosition() - { - //this.arm.upperArm.position = this.shoulderAnker.position; - } */ - - calcElbowInnerAngle() - { - const eulerAngles = new Vector3(); - const targetShoulderDistance = new Vector3().subVectors(this.target.position, this.upperArmPos).magnitude; - let innerAngle; - - if (targetShoulderDistance > this.arm.armLength) - { - innerAngle = 0; - } - else - { - innerAngle = Mathf.Acos(Mathf.Clamp((Mathf.Pow(this.arm.upperArmLength, 2) + Mathf.Pow(this.arm.lowerArmLength, 2) - - Mathf.Pow(targetShoulderDistance, 2)) / (2 * this.arm.upperArmLength * this.arm.lowerArmLength), -1, 1)) * Mathf.Rad2Deg; - // console.log('inner handle', this.target.position.toArray().join(','), this.upperArmPos.toArray().join(',')); - if (this.left) - innerAngle = 180 - innerAngle; - else - innerAngle = 180 + innerAngle; - if (isNaN(innerAngle)) - { - innerAngle = 180; - } - } - - eulerAngles.y = innerAngle; - this.nextLowerArmAngle = eulerAngles; - } - - //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp - rotateShoulder() - { - const eulerAngles = new Vector3(); - const targetShoulderDirection = new Vector3().subVectors(this.target.position, this.upperArmPos).normalized; - const targetShoulderDistance = new Vector3().subVectors(this.target.position, this.upperArmPos).magnitude; - - eulerAngles.y = (this.left ? -1 : 1) * - Mathf.Acos(Mathf.Clamp((Mathf.Pow(targetShoulderDistance, 2) + Mathf.Pow(this.arm.upperArmLength, 2) - - Mathf.Pow(this.arm.lowerArmLength, 2)) / (2 * targetShoulderDistance * this.arm.upperArmLength), -1, 1)) * Mathf.Rad2Deg; - if (isNaN(eulerAngles.y)) - eulerAngles.y = 0; - - - const shoulderRightOffset = this.target.position.sub(this.upperArmPos); - const shoulderRightRotation = new Quaternion().setFromRotationMatrix( - new THREE.Matrix4().lookAt( - new Vector3(), - shoulderRightOffset, - new Vector3(0, 1, 0) - ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.left ? -1 : 1) * Math.PI/2)); - - // const shoulderRightRotation = new Quaternion().setFromUnitVectors(this.armDirection, targetShoulderDirection); - this.setUpperArmRotation(shoulderRightRotation); - this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(eulerAngles.y, Vector3.up.applyQuaternion(this.lowerArmRotation)), this.arm.upperArm.rotation); - this.setLowerArmLocalRotation(Quaternion.Euler(this.nextLowerArmAngle)); - } - - getElbowTargetAngle() - { - const localHandPosNormalized = this.shoulderAnker.InverseTransformPoint(this.handPos).divideScalar(this.arm.armLength); - - // angle from Y - let angle = this.elbowSettings.yWeight * localHandPosNormalized.y + this.elbowSettings.offsetAngle; - - // angle from Z - /*angle += Mathf.Lerp(elbowSettings.zWeightBottom, elbowSettings.zWeightTop, Mathf.Clamp01((localHandPosNormalized.y + 1f) - elbowSettings.zBorderY)) * - (Mathf.Max(elbowSettings.zDistanceStart - localHandPosNormalized.z, 0f));*/ - if (localHandPosNormalized.y > 0) - angle += this.elbowSettings.zWeightTop * (Mathf.Max(this.elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(localHandPosNormalized.y, 0)); - else - angle += this.elbowSettings.zWeightBottom * (Mathf.Max(this.elbowSettings.zDistanceStart - localHandPosNormalized.z, 0) * Mathf.Max(-localHandPosNormalized.y, 0)); - - - // angle from X - angle += this.elbowSettings.xWeight * Mathf.Max(localHandPosNormalized.x * (this.left ? 1.0 : -1.0) + this.elbowSettings.xDistanceStart, 0); - - if (this.elbowSettings.clampElbowAngle) - { - if (this.elbowSettings.softClampElbowAngle) - { - if (angle < this.elbowSettings.minAngle + this.elbowSettings.softClampRange) - { - const a = this.elbowSettings.minAngle + this.elbowSettings.softClampRange - angle; - angle = this.elbowSettings.minAngle + this.elbowSettings.softClampRange * (1 - Mathf.Log(1 + a) * 3); - } - } - else - { - angle = Mathf.Clamp(angle, this.elbowSettings.minAngle, this.elbowSettings.maxAngle); - } - } - - if (this.left) - angle *= -1; - - return angle; - } - - correctElbowRotation() - { - const s = this.beforePositioningSettings; - - const localTargetPos = this.shoulderAnker.InverseTransformPoint(this.target.position).divideScalar(this.arm.armLength); - const elbowOutsideFactor = Mathf.Clamp01( - Mathf.Clamp01((s.startBelowZ - localTargetPos.z) / - Mathf.Abs(s.startBelowZ) * .5) * - Mathf.Clamp01((localTargetPos.y - s.startAboveY) / - Mathf.Abs(s.startAboveY)) * - Mathf.Clamp01(1 - localTargetPos.x * (this.left ? -1 : 1)) - ) * s.weight; - - const shoulderHandDirection = new Vector3().subVectors(this.upperArmPos, this.handPos).normalized; - const targetDir = new Vector3().addVectors(Vector3.up, (s.correctElbowOutside ? new Vector3().addVectors(this.armDirection, Vector3.forward.multiplyScalar(-.2)).multiplyScalar(elbowOutsideFactor) : Vector3.zero)).applyQuaternion(this.shoulder.transform.rotation); - const cross = Vector3.Cross(shoulderHandDirection, targetDir.clone().multiplyScalar(1000)); - - const upperArmUp = Vector3.up.applyQuaternion(this.upperArmRotation); - - const elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - const elbowAngle = (cross.equals(Vector3.zero) ? 0 : Vector3.Angle(cross, upperArmUp)) + (this.left ? 0 : 180); - const rotation = Quaternion.AngleAxis(elbowAngle * Mathf.Sign(elbowTargetUp), shoulderHandDirection); - this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.arm.upperArm.rotation); - } - - /// - /// reduces calculation problems when hand is moving around shoulder XZ coordinates -> forces elbow to be outside of body - /// - correctElbowAfterPositioning() - { - const s = this.elbowCorrectionSettings; - const localTargetPos = this.shoulderAnker.InverseTransformPoint(this.target.position).divideScalar(this.arm.armLength); - const shoulderHandDirection = new Vector3().subVectors(this.upperArmPos, this.handPos).normalized; - const elbowPos = s.localElbowPos; - - if (this.left) - elbowPos.x *= -1; - - const targetDir = elbowPos.normalized.applyQuaternion(this.shoulder.transform.rotation); - const cross = Vector3.Cross(shoulderHandDirection, targetDir); - - const upperArmUp = Vector3.up.applyQuaternion(this.upperArmRotation); - - - let distance = new Vector3().subVectors(this.target.position, this.upperArmPos); - distance = this.shoulder.transform.InverseTransformDirection(distance.clone().divideScalar(distance.magnitude)).multiplyScalar(distance.magnitude); - - const weight = Mathf.Clamp01(Mathf.Clamp01((s.startBelowDistance - distance.xz().magnitude / this.arm.armLength) / - s.startBelowDistance) * s.weight + Mathf.Clamp01((-distance.z + .1) * 3)) * - Mathf.Clamp01((s.startBelowY - localTargetPos.y) / - s.startBelowY); - - const elbowTargetUp = Vector3.Dot(upperArmUp, targetDir); - const elbowAngle2 = Vector3.Angle(cross, upperArmUp) + (this.left ? 0 : 180); - const rotation = Quaternion.AngleAxis(toSignedEulerAngle(elbowAngle2 * Mathf.Sign(elbowTargetUp)) * Mathf.Clamp(weight, 0, 1), shoulderHandDirection); - this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.arm.upperArm.rotation); - } - - rotateElbow(angle) - { - const shoulderHandDirection = new Vector3().subVectors(this.upperArmPos, this.handPos).normalized; - - const rotation = Quaternion.AngleAxis(angle, shoulderHandDirection); - this.setUpperArmRotation(new Quaternion().multiplyQuaternions(rotation, this.upperArmRotation)); - } - - //source: https://github.com/NickHardeman/ofxIKArm/blob/master/src/ofxIKArm.cpp - positionElbow() - { - const targetElbowAngle = this.getElbowTargetAngle(); - this.rotateElbow(targetElbowAngle); - } - - - rotateElbowWithHandRight() - { - const s = this.handSettings; - let handUpVec = Vector3.up.applyQuaternion(this.target.rotation); - const forwardAngle = VectorHelpers.getAngleBetween(Vector3.right.applyQuaternion(this.lowerArmRotation), Vector3.right.applyQuaternion(this.target.rotation), - Vector3.up.applyQuaternion(this.lowerArmRotation), Vector3.forward.applyQuaternion(this.lowerArmRotation)); - - // todo reduce influence if hand local forward rotation is high (hand tilted inside) - const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, Vector3.forward.applyQuaternion(this.lowerArmRotation)); - handUpVec = handUpVec.applyQuaternion(handForwardRotation); - - const elbowTargetAngle = VectorHelpers.getAngleBetween(Vector3.up.applyQuaternion(this.lowerArmRotation), handUpVec, - Vector3.forward.applyQuaternion(this.lowerArmRotation), this.armDirection.clone().applyQuaternion(this.lowerArmRotation)); - - let deltaElbow = (elbowTargetAngle + (this.left ? -s.handDeltaOffset : s.handDeltaOffset)) / 180; - - deltaElbow = Mathf.Sign(deltaElbow) * Mathf.Pow(Mathf.Abs(deltaElbow), s.handDeltaPow) * 180 * s.handDeltaFactor; - this.interpolatedDeltaElbow = - Mathf.LerpAngle(this.interpolatedDeltaElbow, deltaElbow, Time.deltaTime / s.rotateElbowWithHandDelay); - this.rotateElbow(this.interpolatedDeltaElbow); - } - - rotateElbowWithHandFoward() - { - const s = this.handSettings; - const handRightVec = this.armDirection.clone().applyQuaternion(this.target.rotation); - - const elbowTargetAngleForward = VectorHelpers.getAngleBetween(this.armDirection.clone().applyQuaternion(this.lowerArmRotation), handRightVec, - Vector3.up.applyQuaternion(this.lowerArmRotation), Vector3.forward.applyQuaternion(this.lowerArmRotation)); - - let deltaElbowForward = (elbowTargetAngleForward + (this.left ? -s.handDeltaForwardOffset : s.handDeltaForwardOffset)) / 180; - - if (Mathf.Abs(deltaElbowForward) < s.handDeltaForwardDeadzone) - deltaElbowForward = 0; - else - { - deltaElbowForward = (deltaElbowForward - Mathf.Sign(deltaElbowForward) * s.handDeltaForwardDeadzone) / (1 - s.handDeltaForwardDeadzone); - } - - deltaElbowForward = Mathf.Sign(deltaElbowForward) * Mathf.Pow(Mathf.Abs(deltaElbowForward), s.handDeltaForwardPow) * 180; - this.interpolatedDeltaElbowForward = Mathf.LerpAngle(this.interpolatedDeltaElbowForward, deltaElbowForward, Time.deltaTime / s.rotateElbowWithHandDelay); - - const signedInterpolated = toSignedEulerAngle(this.interpolatedDeltaElbowForward); - this.rotateElbow(signedInterpolated * s.handDeltaForwardFactor); - } - - rotateHand() - { - /* if (this.handSettings.useWristRotation) - { - let handUpVec = Vector3.up.applyQuaternion(this.target.rotation); - const forwardAngle = VectorHelpers.getAngleBetween(Vector3.right.applyQuaternion(this.lowerArmRotation), Vector3.right.applyQuaternion(this.target.rotation), - Vector3.up.applyQuaternion(this.lowerArmRotation), Vector3.forward.applyQuaternion(this.lowerArmRotation)); - - // todo reduce influence if hand local forward rotation is high (hand tilted inside) - const handForwardRotation = Quaternion.AngleAxis(-forwardAngle, Vector3.forward.applyQuaternion(this.lowerArmRotation)); - handUpVec = handUpVec.applyQuaternion(handForwardRotation); - - let elbowTargetAngle = VectorHelpers.getAngleBetween(Vector3.up.applyQuaternion(this.lowerArmRotation), handUpVec, - Vector3.forward.applyQuaternion(this.lowerArmRotation), this.armDirection.clone().applyQuaternion(this.lowerArmRotation)); - - elbowTargetAngle = Mathf.Clamp(elbowTargetAngle, -90, 90); - if (this.arm.wrist1 !== null) - this.setWrist1Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .3, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); - if (this.arm.wrist2 !== null) - this.setWrist2Rotation(new Quaternion().multiplyQuaternions(Quaternion.AngleAxis(elbowTargetAngle * .8, this.armDirection.clone().applyQuaternion(this.lowerArmRotation)), this.lowerArmRotation)); - } */ - const targetRotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); - this.setHandRotation(targetRotation); - } - - removeShoulderRightRotation(direction) { - return this.direction.clone().applyQuaternion(Quaternion.AngleAxis(-this.shoulderPoser.shoulderRightRotation, this.shoulder.transform.right)); - } - - get armDirection() { - return this.left ? Vector3.left : Vector3.right; - } - get upperArmPos() { - return this.arm.upperArm.position; - } - get lowerArmPos() { - return this.arm.lowerArm.position; - } - get handPos() { - return this.arm.hand.position; - } - get shoulderAnker() { - return this.left ? this.shoulder.leftShoulderAnchor : this.shoulder.rightShoulderAnchor; - } - - get upperArmRotation() { - return new Quaternion().multiplyQuaternions(this.arm.upperArm.rotation, Quaternion.Inverse(this.upperArmStartRotation)); - } - get lowerArmRotation() { - return new Quaternion().multiplyQuaternions(this.arm.lowerArm.rotation, Quaternion.Inverse(this.lowerArmStartRotation)); - } - get handRotation() { - return new Quaternion().multiplyQuaternions(this.arm.hand.rotation, Quaternion.Inverse(this.handStartRotation)); - } - - setUpperArmRotation(rotation) { - return this.arm.upperArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.upperArmStartRotation); - } - setLowerArmRotation(rotation) { - return this.arm.lowerArm.rotation = new Quaternion().multiplyQuaternions(rotation, this.lowerArmStartRotation); - } - setLowerArmLocalRotation(rotation) { - return this.arm.lowerArm.rotation = new Quaternion().multiplyQuaternions(new Quaternion().multiplyQuaternions(this.upperArmRotation, rotation), this.lowerArmStartRotation); - } - /* setWrist1Rotation(rotation) { - return this.arm.wrist1.rotation = new Quaternion().multiplyQuaternions(rotation, this.wristStartRotation); - } - setWrist2Rotation(rotation) { - return this.arm.wrist2.rotation = new Quaternion().multiplyQuaternions(rotation, this.wristStartRotation); - } - setWristLocalRotation(rotation) { - return this.arm.wrist1.rotation = new Quaternion().multiplyQuaternions(new Quaternion().multiplyQuaternions(this.arm.lowerArm.rotation, rotation), this.wristStartRotation); - } */ - setHandRotation(rotation) { - return this.arm.hand.rotation = /* this.arm.hand.rotation = */ new Quaternion().multiplyQuaternions(rotation, this.handStartRotation); - } } export default VRArmIK; From 82b73df6e5b5fa481e4fb5248b16f3595c273775 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 00:51:09 -0400 Subject: [PATCH 360/562] Increase default user height to 1.7 --- vrarmik.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vrarmik.html b/vrarmik.html index a7f68d7..dfb1fac 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -727,7 +727,7 @@

Multiplayer

})(); scene.add(mirrorMesh); -const userHeight = 1.65; +const userHeight = 1.7; const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); let rig = null; From ee09e3b5ab5bdd98220be9a6243c6fea33d5a5eb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 00:51:42 -0400 Subject: [PATCH 361/562] Initialize finger gamepad input values --- vrarmik/VRTrackingReferences.js | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js index afb6efa..802e81c 100644 --- a/vrarmik/VRTrackingReferences.js +++ b/vrarmik/VRTrackingReferences.js @@ -9,7 +9,11 @@ import {Transform} from './Unity.js'; console.log('change 1', new Error().stack); }; */ this.leftHand = new Transform(); + this.leftHand.pointer = 0; + this.leftHand.grip = 0; this.rightHand = new Transform(); + this.rightHand.pointer = 0; + this.rightHand.grip = 0; this.head = new Transform(); /* this.head.onchange = () => { console.log('change 2', new Error().stack); From 9e5aa8f853312c6920e3ef369e8c9af8883a3604 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 00:53:04 -0400 Subject: [PATCH 362/562] Read finger input values --- vrarmik.html | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index dfb1fac..f0ae40a 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -791,11 +791,15 @@

Multiplayer

const q = new Quaternion().copy(orientation); const pressed = gamepad.buttons[0].pressed; const lastPressed = lastPresseds[i]; + const pointer = gamepad.buttons[0].value; + const grip = gamepad.buttons[1].value; return { position: p, rotation: q, pressed, lastPressed, + pointer, + grip, }; } else if (matrix) { // old WebXR api const p = new Vector3().multiplyScalar(heightFactor); @@ -805,11 +809,15 @@

Multiplayer

.decompose(p, q, s); const pressed = gamepad.buttons[0].pressed; const lastPressed = lastPresseds[i]; + const pointer = gamepad.buttons[0].value; + const grip = gamepad.buttons[1].value; return { position: p, rotation: q, pressed, lastPressed, + pointer, + grip, }; } else { return null; @@ -822,9 +830,11 @@

Multiplayer

const lg = _getGamepad(1); let li = -1; if (lg) { - const {position, rotation, pressed, lastPressed} = lg; + const {position, rotation, pressed, lastPressed, pointer, grip} = lg; rig.inputs.leftGamepad.rotation = rotation; rig.inputs.leftGamepad.position = position; + rig.inputs.leftGamepad.pointer = pointer; + rig.inputs.leftGamepad.grip = grip; li = mirrorMesh.getButtonIntersectionIndex(position); if (pressed && !lastPressed) { if (li !== -1) { @@ -837,9 +847,11 @@

Multiplayer

const rg = _getGamepad(0); let ri = -1; if (rg) { - const {position, rotation, pressed, lastPressed} = rg; + const {position, rotation, pressed, lastPressed, pointer, grip} = rg; rig.inputs.rightGamepad.rotation = rotation; rig.inputs.rightGamepad.position = position; + rig.inputs.rightGamepad.pointer = pointer; + rig.inputs.rightGamepad.grip = grip; ri = mirrorMesh.getButtonIntersectionIndex(position); if (pressed && !lastPressed) { if (ri !== -1) { @@ -876,6 +888,12 @@

Multiplayer

).add( new Vector3(0.1, 0, -1).normalize().multiplyScalar(rig.leftArmLength*0.7).applyQuaternion(rig.inputs.leftGamepad.rotation) ); + + rig.inputs.leftGamepad.pointer = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2; + rig.inputs.leftGamepad.grip = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2; + + rig.inputs.rightGamepad.pointer = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2; + rig.inputs.rightGamepad.grip = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2; } rig.update(); From 8c8e0d266504c2d5b38983ebd62b20d8b44859b7 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 01:00:05 -0400 Subject: [PATCH 363/562] Add finger bones loading --- vrarmik/Rig.js | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index dea7dda..6f622e2 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -397,6 +397,41 @@ class Rig { } this.hairBones = hairBones; + const _findFinger = (r, left) => { + const fingerTipBone = tailBones + .filter(bone => r.test(bone.name) && _findClosestParentBone(bone, bone => bone === modelBones.Left_wrist || bone === modelBones.Right_wrist)) + .sort((a, b) => { + const aName = a.name.replace(r, ''); + const aLeftBalance = _countCharacters(aName, /l/i) - _countCharacters(aName, /r/i); + const bName = b.name.replace(r, ''); + const bLeftBalance = _countCharacters(bName, /l/i) - _countCharacters(bName, /r/i); + if (!left) { + return aLeftBalance - bLeftBalance; + } else { + return bLeftBalance - aLeftBalance; + } + }); + const fingerRootBone = fingerTipBone.length > 0 ? _findFurthestParentBone(fingerTipBone[0], bone => r.test(bone.name)) : null; + return fingerRootBone; + }; + const fingerBones = { + left: { + thumb: _findFinger(/thumb/gi, true), + index: _findFinger(/index/gi, true), + middle: _findFinger(/middle/gi, true), + ring: _findFinger(/ring/gi, true), + little: _findFinger(/little/gi, true) || _findFinger(/pinky/gi, true), + }, + right: { + thumb: _findFinger(/thumb/gi, false), + index: _findFinger(/index/gi, false), + middle: _findFinger(/middle/gi, false), + ring: _findFinger(/ring/gi, false), + little: _findFinger(/little/gi, false) || _findFinger(/pinky/gi, false), + }, + }; + this.fingerBones = fingerBones; + const preRotations = {}; const _ensurePrerotation = k => { const boneName = modelBones[k].name; From eb7efa08eb56c2a08bbf43c0d66f9bf4d86ac401 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 01:00:15 -0400 Subject: [PATCH 364/562] Add finger bones processing --- vrarmik/Rig.js | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 6f622e2..908c464 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -803,6 +803,35 @@ class Rig { const timeDiff = Math.min(now - this.lastTimestamp, 1000); this.lastTimestamp = now; + if (this.options.fingers) { + const _processFingerBones = left => { + const fingerBones = left ? this.fingerBones.left : this.fingerBones.right; + const gamepadInput = left ? this.inputs.rightGamepad : this.inputs.leftGamepad; + for (const k in fingerBones) { + const fingerBone = fingerBones[k]; + if (fingerBone) { + const axis = new Vector3(); + let angle; + if (k === 'thumb') { + axis.set(0, left ? 1 : -1, 0); + angle = gamepadInput.grip * Math.PI*0.25; + } else if (k === 'index') { + axis.set(0, 0, left ? -1 : 1); + angle = gamepadInput.pointer * Math.PI*0.5; + } else { + axis.set(0, 0, left ? -1 : 1); + angle = gamepadInput.grip * Math.PI*0.5; + } + fingerBone.traverse(subFingerBone => { + subFingerBone.quaternion.setFromAxisAngle(axis, angle); + }); + } + } + }; + _processFingerBones(true); + _processFingerBones(false); + } + if (this.options.hair) { const _processHairBone = (hairBone, children) => { const p = new Vector3().setFromMatrixPosition(hairBone.matrixWorld); From a25981aa9899bf0fbb95775f2132dbd6d924c5fb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 01:00:33 -0400 Subject: [PATCH 365/562] Flag finger bones enabled in avatars demo --- vrarmik.html | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vrarmik.html b/vrarmik.html index f0ae40a..cd19e4f 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -744,6 +744,7 @@

Multiplayer

model = object; rig = new Rig(model, { + fingers: true, hair: true, visemes: true, microphoneMediaStream, @@ -1166,6 +1167,7 @@

Multiplayer

scene.add(peerConnection.model); peerConnection.rig = new Rig(peerConnection.model, { + fingers: true, hair: true, visemes: true, microphoneMediaStream: peerConnection.mediaStream, From da724054b254f401a6850bc41a37110868ed4ef4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 02:34:35 -0400 Subject: [PATCH 366/562] Bugfix gamepad indices again --- vrarmik.html | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index cd19e4f..1ec4665 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -828,7 +828,7 @@

Multiplayer

} }; - const lg = _getGamepad(1); + const lg = _getGamepad(0); let li = -1; if (lg) { const {position, rotation, pressed, lastPressed, pointer, grip} = lg; @@ -845,7 +845,7 @@

Multiplayer

lastPresseds[0] = pressed; } - const rg = _getGamepad(0); + const rg = _getGamepad(1); let ri = -1; if (rg) { const {position, rotation, pressed, lastPressed, pointer, grip} = rg; From 8a574a27d8e3641b791ed2c3c4ccd3d754270dc0 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 02:40:58 -0400 Subject: [PATCH 367/562] More input sources handedness debugging --- vrarmik.html | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 1ec4665..10d44b2 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -782,7 +782,8 @@

Multiplayer

rig.inputs.hmd.rotation = vrCamera.quaternion; const _getGamepad = i => { - const inputSource = inputSources[i]; + const handedness = i === 0 ? 'left' : 'right'; + const inputSource = inputSources.find(inputSource => inputSource.handedness === handedness); let pose, gamepad; if (inputSource && (pose = frame.getPose(inputSource.targetRaySpace, referenceSpace)) && (gamepad = inputSource.gamepad || gamepads[i])) { const {transform} = pose; @@ -828,7 +829,7 @@

Multiplayer

} }; - const lg = _getGamepad(0); + const lg = _getGamepad(1); let li = -1; if (lg) { const {position, rotation, pressed, lastPressed, pointer, grip} = lg; @@ -845,7 +846,7 @@

Multiplayer

lastPresseds[0] = pressed; } - const rg = _getGamepad(1); + const rg = _getGamepad(0); let ri = -1; if (rg) { const {position, rotation, pressed, lastPressed, pointer, grip} = rg; From 4ebd3032ffef4b5b6b27e6fe769615608aa61220 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 02:48:43 -0400 Subject: [PATCH 368/562] Small legs cleanup --- vrarmik/LegsManager.js | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index d2898a3..ded03ff 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -33,6 +33,7 @@ class Leg { this.foot.stickTransform.position = this.foot.position; this.upperLegLength = this.lowerLeg.localPosition.length(); this.lowerLegLength = this.foot.localPosition.length(); + this.legLength = this.upperLegLength + this.lowerLegLength; } Update() { @@ -84,19 +85,11 @@ class Leg { } */ const footPosition = this.foot.stickTransform.position; - const {upperLegLength, lowerLegLength} = this; - // const upperLegLength = this.lowerLeg.localPosition.length(); - // const lowerLegLength = this.foot.localPosition.length(); - const g = this.upperLeg.position.add(footPosition.clone().sub(this.upperLeg.position).normalize().multiplyScalar(upperLegLength + lowerLegLength)); - /* if (this.left) { - console.log('check', g.y, footPosition.y, this.foot.position.y); - } */ + const {upperLegLength, lowerLegLength, legLength} = this; + const g = this.upperLeg.position.add(footPosition.clone().sub(this.upperLeg.position).normalize().multiplyScalar(legLength)); if (g.y <= 0) { footPosition.y = 0; - // const footRotation = this.upperLeg.rotation; const footRotation = this.foot.stickTransform.rotation; - // const footRotation = new Quaternion().setFromEuler(footEuler); - // const footRotation = this.foot.rotation; const hypotenuseDistance = upperLegLength; const verticalDistance = Math.abs(this.upperLeg.position.y) / 2; From 0f7909fb74fd1d6cc686da39447025745016afcb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:38:11 -0400 Subject: [PATCH 369/562] Small unity emulation cleanup --- vrarmik/Unity.js | 1 + 1 file changed, 1 insertion(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 630b73d..3a30aeb 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -406,6 +406,7 @@ const Time = { const Mathf = { Deg2Rad: DEG2RAD, Rad2Deg: RAD2DEG, + Order: ORDER, PI: Math.PI, Clamp(v, min, max) { return Math.min(Math.max(v, min), max); From 35f6420f02f6a8149f11087eb68d9667d2367f7a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:38:33 -0400 Subject: [PATCH 370/562] Expose unity transform matrix/matrixWorld --- vrarmik/Unity.js | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index 3a30aeb..dfb8db2 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -243,6 +243,16 @@ class Transform { this._localScale.copy(localScale); } + get matrix() { + this.updateLocalMatrix(); + return this._matrix.clone(); + } + + get matrixWorld() { + this.updateMatrixWorld(); + return this._matrixWorld.clone(); + } + get parent() { return this._parent; } From ecf5f54c350cf50bd283df4a65053cd989fd7924 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:39:53 -0400 Subject: [PATCH 371/562] Small VRArmIK cleanup --- vrarmik/ShoulderTransforms.js | 5 ++--- vrarmik/VRArmIK.js | 10 ++++++++-- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 155de2a..8e5b9eb 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -43,16 +43,15 @@ class ShoulderTransforms this.shoulderPoser = new ShoulderPoser(rig, this); - this.leftArmIk = new VRArmIK(this.leftArm); + this.leftArmIk = new VRArmIK(this.leftArm, true); this.leftArmIk.shoulder = this; this.leftArmIk.shoulderPoser = this.shoulderPoser; this.leftArmIk.target = this.leftArmIk.shoulderPoser.avatarTrackingReferences.leftHand; - this.rightArmIk = new VRArmIK(this.rightArm); + this.rightArmIk = new VRArmIK(this.rightArm, false); this.rightArmIk.shoulder = this; this.rightArmIk.shoulderPoser = this.shoulderPoser; this.rightArmIk.target = this.rightArmIk.shoulderPoser.avatarTrackingReferences.rightHand; - this.rightArmIk.left = false; } Start() diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 780eb3f..a82d1d1 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -5,12 +5,18 @@ import VectorHelpers from './Utils/VectorHelpers.js'; class VRArmIK { - constructor(arm) { + constructor(arm, left) { this.arm = arm; this.shoulder = null; this.shoulderPoser = null; this.target = new Transform(); - this.left = true; + this.left = left; + + this.upperArmStartRotation = new Quaternion(); + this.lowerArmStartRotation = new Quaternion(); + this.upperArmLength = 0; + this.lowerArmLength = 0; + this.armLength = 0; } Start() From 807584580d6693edd6d8f362fb954996a1e732b7 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:40:27 -0400 Subject: [PATCH 372/562] More pose flow cleanup --- vrarmik/ArmTransforms.js | 4 +- vrarmik/ShoulderPoser.js | 69 +++++++++++++++++------------------ vrarmik/ShoulderTransforms.js | 6 +-- 3 files changed, 38 insertions(+), 41 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index 30779ac..ae69b94 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -42,11 +42,11 @@ class ArmTransforms return a.position.distanceTo(b.position); } - Start() + /* Start() { // PoseManager.Instance.onCalibrate += this.updateArmLengths; // this.updateArmLengths(); - } + } */ updateArmLengths() { diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index b0c28a4..5122cdd 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -49,15 +49,14 @@ class ShoulderPoser // this.lastAngle = Vector3.zero; - this.leftShoulderAnkerStartLocalPosition = new Vector3(); - this.rightShoulderAnkerStartLocalPosition = new Vector3(); + // this.leftShoulderAnkerStartLocalPosition = new Vector3(); + // this.rightShoulderAnkerStartLocalPosition = new Vector3(); } - Start() { - this.leftShoulderAnkerStartLocalPosition = this.shoulder.transform.InverseTransformPoint(this.shoulder.leftShoulderAnchor.position); - this.rightShoulderAnkerStartLocalPosition = - this.shoulder.transform.InverseTransformPoint(this.shoulder.rightShoulderAnchor.position); - } + /* Start() { + this.leftShoulderAnkerStartLocalPosition = this.shoulder.leftShoulderAnchor.localPosition.clone(); + this.rightShoulderAnkerStartLocalPosition = this.shoulder.rightShoulderAnchor.position.clone(); + } */ /* onCalibrate() { @@ -73,14 +72,15 @@ class ShoulderPoser // this.shoulder.transform.rotation = Quaternion.identity; // this.positionShoulder(); - this.rotateShoulderUpBase(); - this.rotateShoulderRightBase(); + let rotation = this.rotateShoulderUpBase(); + rotation = this.rotateShoulderRightBase(rotation); + this.shoulder.transform.rotation = rotation; - if (this.enableDistinctShoulderRotation) + /* if (this.enableDistinctShoulderRotation) { - this.rotateLeftShoulder(); - this.rotateRightShoulder(); - } + this.rotateLeftShoulder(rotation); + this.rotateRightShoulder(rotation); + } */ /* if (this.enableShoulderDislocation) { @@ -134,46 +134,41 @@ class ShoulderPoser this.shoulder.head.localRotation = hmdUpRotation; } - rotateLeftShoulder() + /* rotateLeftShoulder(shoulderRotation) { - this.rotateShoulderUp(this.shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand, - this.leftShoulderAnkerStartLocalPosition, 1); - + this.rotateShoulderUp(this.shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand, this.leftShoulderAnkerStartLocalPosition, 1, shoulderRotation); } - rotateRightShoulder() + rotateRightShoulder(shoulderRotation) { - this.rotateShoulderUp(this.shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand, - this.rightShoulderAnkerStartLocalPosition, -1); + this.rotateShoulderUp(this.shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand, this.rightShoulderAnkerStartLocalPosition, -1, shoulderRotation); } - rotateShoulderUp(shoulderSide, arm, targetHand, - initialShoulderLocalPos, angleSign) + rotateShoulderUp(shoulderSide, arm, targetHand, initialShoulderLocalPos, angleSign, shoulderRotation) { - const initialShoulderPos = this.shoulder.transform.TransformPoint(initialShoulderLocalPos); + const initialShoulderPos = initialShoulderLocalPos.clone().applyMatrix4(this.shoulder.transform.matrixWorld); const handShoulderOffset = new Vector3().subVectors(targetHand.position, initialShoulderPos); const armLength = arm.armLength; const targetAngle = Vector3.zero; - const forwardDistanceRatio = Vector3.Dot(handShoulderOffset, this.shoulder.transform.forward) / armLength; - const upwardDistanceRatio = Vector3.Dot(handShoulderOffset, this.shoulder.transform.up) / armLength; + const forwardDistanceRatio = Vector3.Dot(handShoulderOffset, Vector3.forward.applyQuaternion(shoulderRotation)) / armLength; + const upwardDistanceRatio = Vector3.Dot(handShoulderOffset, Vector3.up.applyQuaternion(shoulderRotation)) / armLength; if (forwardDistanceRatio > 0) { - targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, 0, - this.distinctShoulderRotationLimitForward); + targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, 0, this.distinctShoulderRotationLimitForward); } else { - targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08) * this.distinctShoulderRotationMultiplier * 10, - -this.distinctShoulderRotationLimitBackward, 0); + targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08) * this.distinctShoulderRotationMultiplier * 10, -this.distinctShoulderRotationLimitBackward, 0); } - targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, - -this.distinctShoulderRotationLimitUpward, 0); + targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, -this.distinctShoulderRotationLimitUpward, 0); - shoulderSide.localEulerAngles = targetAngle * angleSign; - } + targetAngle.multiplyScalar(angleSign); + + shoulderSide.localRotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(targetAngle.x * Mathf.Deg2Rad, targetAngle.y * Mathf.Deg2Rad, targetAngle.z * Mathf.Deg2Rad, Mathf.Order)); + } */ positionShoulder() @@ -200,10 +195,11 @@ class ShoulderPoser this.clampHeadRotationDeltaUp(targetRotation); } - this.shoulder.transform.eulerAngles = targetRotation; + // this.shoulder.transform.eulerAngles = targetRotation; + return new THREE.Quaternion().setFromEuler(new THREE.Euler(targetRotation.x * Mathf.Deg2Rad, targetRotation.y * Mathf.Deg2Rad, targetRotation.z * Mathf.Deg2Rad, Mathf.Order)) } - rotateShoulderRightBase() + rotateShoulderRightBase(rotation) { const heightDiff = this.vrTrackingReferences.head.position.y - this.poseManager.vrSystemOffsetHeight; @@ -223,7 +219,8 @@ class ShoulderPoser const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right); - this.shoulder.transform.rotation = new Quaternion().multiplyQuaternions(deltaRot, this.shoulder.transform.rotation); + // this.shoulder.transform.rotation = new Quaternion().multiplyQuaternions(deltaRot, this.shoulder.transform.rotation); + return new Quaternion().multiplyQuaternions(deltaRot, rotation); // this.positionShoulderRelative(); } diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index 8e5b9eb..d4f65f3 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -58,9 +58,9 @@ class ShoulderTransforms { // this.setShoulderWidth(PoseManager.Instance.playerWidthShoulders); - this.leftArm.Start(); - this.rightArm.Start(); - this.shoulderPoser.Start(); + // this.leftArm.Start(); + // this.rightArm.Start(); + // this.shoulderPoser.Start(); this.leftArmIk.Start(); this.rightArmIk.Start(); } From 7596a04ab267c7ef967b4822b7c4b351a5513ee4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:41:40 -0400 Subject: [PATCH 373/562] VRArmIK cleanup again --- vrarmik/VRArmIK.js | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index a82d1d1..c8323ac 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -12,8 +12,6 @@ import VectorHelpers from './Utils/VectorHelpers.js'; this.target = new Transform(); this.left = left; - this.upperArmStartRotation = new Quaternion(); - this.lowerArmStartRotation = new Quaternion(); this.upperArmLength = 0; this.lowerArmLength = 0; this.armLength = 0; @@ -21,8 +19,6 @@ import VectorHelpers from './Utils/VectorHelpers.js'; Start() { - this.upperArmStartRotation = this.arm.upperArm.rotation; - this.lowerArmStartRotation = this.arm.lowerArm.rotation; this.upperArmLength = this.arm.lowerArm.position.distanceTo(this.arm.upperArm.position); this.lowerArmLength = this.arm.hand.position.distanceTo(this.arm.lowerArm.position); this.armLength = this.upperArmLength + this.lowerArmLength; @@ -30,9 +26,6 @@ import VectorHelpers from './Utils/VectorHelpers.js'; Update() { - // const targetPosition = this.target.position; - // const targetRotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); - const handPositionDistance = this.target.position.distanceTo(this.arm.upperArm.position); let handPosition; // if (handPositionDistance < this.armLength) { @@ -48,9 +41,6 @@ import VectorHelpers from './Utils/VectorHelpers.js'; const hypotenuseDistance = this.upperArmLength; const directDistance = this.arm.upperArm.position.distanceTo(handPosition) / 2; - /* if (this.left) { - console.log('distances', hypotenuseDistance, directDistance); - } */ const offsetDistance = hypotenuseDistance > directDistance ? Math.sqrt(hypotenuseDistance*hypotenuseDistance - directDistance*directDistance) : 0; // console.log('offset distance', this.upperArmLength, this.lowerArmLength, hypotenuseDistance, directDistance, offsetDistance); // const outFactor = targetEuler.x < 0 ? (1 - Math.min(Math.max(-targetEuler.x/(Math.PI/4), 0), 1)) : 1; @@ -59,8 +49,6 @@ import VectorHelpers from './Utils/VectorHelpers.js'; new Vector3(-1, 0, 0) .applyQuaternion(shoulderRotation/*.clone().premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? 1 : -1) * Math.PI*0.1))*/) ); - //.applyQuaternion(shoulderRotation.clone().multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)))) - // .normalize(); const localOffsetDirection = offsetDirection.clone().applyQuaternion(shoulderRotationInverse); const targetLocalRotation = this.target.rotation.multiply(shoulderRotationInverse).premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI)); @@ -90,8 +78,6 @@ import VectorHelpers from './Utils/VectorHelpers.js'; // targetEuler.z *= 1 - xFactor; // targetEuler.z *= 1 - zFactor; } - // targetEuler.y = 0; - // targetEuler.x = 0; localOffsetDirection.applyAxisAngle(new Vector3(0, 0, 1), targetEuler.z); offsetDirection.copy(localOffsetDirection).applyQuaternion(this.shoulder.transform.rotation); From 348bca4fdf6352cf29eb731f8de98a9b3955e4dc Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:47:10 -0400 Subject: [PATCH 374/562] More unity dead code cleanup --- vrarmik/LegsManager.js | 2 +- vrarmik/PoseManager.js | 5 ++--- vrarmik/Unity.js | 12 ++++++------ vrarmik/VRArmIK.js | 5 +---- 4 files changed, 10 insertions(+), 14 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index ded03ff..c81f640 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -1,4 +1,4 @@ -import {Vector2, Vector3, Quaternion, Transform, GameObject, MonoBehavior, XRSettings} from './Unity.js'; +import {Vector2, Vector3, Quaternion, Transform} from './Unity.js'; const _mod = (a, n) => (a % n + n) % n; const _angleDiff = (targetA, sourceA) => { diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 755ce75..73976d3 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -1,6 +1,6 @@ import VRTrackingReferences from './VRTrackingReferences.js'; import AvatarVRTrackingReferences from './AvatarVRTrackingReferences.js'; -import {Transform, XRSettings} from './Unity.js'; +import {Transform} from './Unity.js'; class PoseManager { @@ -45,8 +45,7 @@ class PoseManager { this.loadPlayerSize(); } - const device = XRSettings.loadedDeviceName; - this.vrSystemOffsetHeight = /*string.IsNullOrEmpty(device) || */device == "OpenVR" ? 0 : this.playerHeightHmd; + this.vrSystemOffsetHeight = 0; } /* Start() diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js index dfb8db2..7101071 100644 --- a/vrarmik/Unity.js +++ b/vrarmik/Unity.js @@ -409,9 +409,9 @@ class MonoBehavior { LateUpdate() {} } -const Time = { +/* const Time = { deltaTime: 1/90, -}; +}; */ const Mathf = { Deg2Rad: DEG2RAD, @@ -494,9 +494,9 @@ const PlayerPrefs = { }, }; -const XRSettings = { +/* const XRSettings = { loadedDeviceName: 'OpenVR', -}; +}; */ /* class Unity { constructor() { @@ -550,9 +550,9 @@ export { Transform, GameObject, MonoBehavior, - Time, + // Time, Mathf, PlayerPrefs, - XRSettings, + // XRSettings, // Unity, }; diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index c8323ac..61456bd 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,7 +1,4 @@ -import {Vector3, Quaternion, Transform, GameObject, Time, Mathf} from './Unity.js'; -import ArmTransforms from './ArmTransforms.js'; -import ShoulderPoser from './ShoulderPoser.js'; -import VectorHelpers from './Utils/VectorHelpers.js'; +import {Vector3, Quaternion, Transform} from './Unity.js'; class VRArmIK { From 3b5529633d11db319196381cb5b1695cf8adb4f4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:47:51 -0400 Subject: [PATCH 375/562] Remove dead StaticOffsetTransform.js --- vrarmik/StaticOffsetTransform.js | 120 ------------------------------- 1 file changed, 120 deletions(-) delete mode 100644 vrarmik/StaticOffsetTransform.js diff --git a/vrarmik/StaticOffsetTransform.js b/vrarmik/StaticOffsetTransform.js deleted file mode 100644 index d278e7e..0000000 --- a/vrarmik/StaticOffsetTransform.js +++ /dev/null @@ -1,120 +0,0 @@ -import {Vector3, Quaternion, Transform} from './Unity.js'; - -const EulerOrder = { - XYZ: 'XYZ', - XZY: 'XZY', - YXZ: 'YXZ', - YZX: 'YZX', - ZXY: 'ZXY', - ZYX: 'ZYX', -}; - -class StaticOffsetTransform - { - constructor() { - this.transform = new Transform(); - - this.reference = null; - this.offsetPosition = new Vector3(); - this.offsetRotation = new Vector3(); - this.orientationalOffset = new Vector3(); - this.referenceRotationMultiplicator = Vector3.one; - - this.axisOrder = EulerOrder.XYZ; - - this.referenceLocalPosition = false; - this.referenceLocalRotation = false; - this.applyLocalPosition = false; - this.applyLocalRotation = false; - this.applyPosition = true; - this.applyRotation = true; - this.applyForwardOffsetAfterRotationOffset = false; - } - - switchAxis(r, order) - { - switch (order) - { - case EulerOrder.XYZ: - return new Vector3(r.x, r.y, r.z); - case EulerOrder.XZY: - return new Vector3(r.x, r.z, r.y); - case EulerOrder.YXZ: - return new Vector3(r.y, r.x, r.z); - case EulerOrder.YZX: - return new Vector3(r.y, r.z, r.x); - case EulerOrder.ZXY: - return new Vector3(r.z, r.x, r.y); - case EulerOrder.ZYX: - return new Vector3(r.z, r.y, r.x); - - default: - return r; - } - } - - /* Awake() - { - this.updatePosition(); - } */ - - Update() - { - this.updatePosition(); - } - - updatePosition() - { - if (this.reference === null) - return; - - const rot = new Vector3().addVectors(this.switchAxis(this.referenceLocalRotation ? this.reference.localEulerAngles : this.reference.eulerAngles, this.axisOrder), - this.offsetRotation); - rot.multiply(this.referenceRotationMultiplicator); - - const pos = this.referenceLocalPosition ? this.reference.localPosition : this.reference.position; - - - if (this.applyForwardOffsetAfterRotationOffset) - { - pos.add(Vector3.right.applyQuaternion(Quaternion.Euler(rot)).multiplyScalar(this.orientationalOffset.x)); - pos.add(Vector3.up.applyQuaternion(Quaternion.Euler(rot)).multiplyScalar(this.orientationalOffset.y)); - pos.add(Vector3.forward.applyQuaternion(Quaternion.Euler(rot)).multiplyScalar(this.orientationalOffset.z)); - } - else - { - pos.add(this.reference.right.multiplyScalar(this.orientationalOffset.x)); - pos.add(this.reference.up.multiplyScalar(this.orientationalOffset.y)); - pos.add(this.reference.forward.multiplyScalar(this.orientationalOffset.z)); - } - - pos.add(this.offsetPosition); - - if (this.applyPosition) - { - if (this.applyLocalPosition) - { - this.transform.localPosition = pos; - } - else - { - this.transform.position = pos; - } - } - - - if (this.applyRotation) - { - if (this.applyLocalRotation) - { - this.transform.localEulerAngles = rot; - } - else - { - this.transform.eulerAngles = rot; - } - } - } - } - -export default StaticOffsetTransform; From 92de40081d70796735ca3939b87fcd26cbe05e6a Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 03:53:56 -0400 Subject: [PATCH 376/562] VRArmIK memory management cleanup --- vrarmik/VRArmIK.js | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 61456bd..23ef249 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -1,5 +1,10 @@ import {Vector3, Quaternion, Transform} from './Unity.js'; +const leftRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2); +const rightRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2); +const bankLeftRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/2); +const bankRightRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI/2); + class VRArmIK { constructor(arm, left) { @@ -87,7 +92,7 @@ import {Vector3, Quaternion, Transform} from './Unity.js'; elbowPosition.clone().sub(this.arm.upperArm.position), new Vector3(this.left ? -1 : 1, 0, 0).applyQuaternion(shoulderRotation) ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.left ? -1 : 1) * Math.PI/2)); + ).multiply(this.left ? rightRotation : leftRotation); // this.arm.lowerArm.position = elbowPosition; this.arm.lowerArm.rotation = new Quaternion().setFromRotationMatrix( @@ -96,10 +101,11 @@ import {Vector3, Quaternion, Transform} from './Unity.js'; handPosition.clone().sub(elbowPosition), new Vector3(this.left ? -1 : 1, 0, 0).applyQuaternion(shoulderRotation) ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (this.left ? -1 : 1) * Math.PI/2)); + ).multiply(this.left ? rightRotation : leftRotation); // this.arm.hand.position = handPosition; - this.arm.hand.rotation = this.target.rotation.multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (this.left ? -1 : 1) * Math.PI/2)); + this.arm.hand.rotation = this.target.rotation + .multiply(this.left ? bankRightRotation : bankLeftRotation); } } From 147457597a8b2bbd13b2347e9b03f76786e52c7d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:04:34 -0400 Subject: [PATCH 377/562] More memory optimizations --- vrarmik/LegsManager.js | 21 +++++++++++++-------- vrarmik/ShoulderPoser.js | 9 +++------ 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index c81f640..73d9ed8 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -1,5 +1,10 @@ import {Vector2, Vector3, Quaternion, Transform} from './Unity.js'; +const identityRotation = new Quaternion(); +const downHalfRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2); +const upHalfRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2); +const downQuarterRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/4); + const _mod = (a, n) => (a % n + n) % n; const _angleDiff = (targetA, sourceA) => { let a = targetA - sourceA; @@ -108,7 +113,7 @@ class Leg { upperLegDiff, new Vector3(0, 0, 1).applyQuaternion(footRotation) ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); + ).multiply(downHalfRotation); this.upperLeg.rotation = upperLegRotation; const lowerLegDiff = lowerLegPosition.clone().sub(footPosition); @@ -118,20 +123,20 @@ class Leg { lowerLegDiff, new Vector3(0, 0, 1).applyQuaternion(footRotation) ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); + ).multiply(downHalfRotation); this.lowerLeg.rotation = lowerLegRotation; // this.lowerLeg.position = lowerLegPosition; // this.foot.position = footPosition; - this.foot.rotation = footRotation.multiply(new Quaternion().setFromUnitVectors(new Vector3(0, -1, 0), new Vector3(0, 0, 1))); + this.foot.rotation = footRotation.multiply(downHalfRotation); this.standing = true; // this.foot.stickTransform.position = footPosition; } else { - this.upperLeg.localRotation = this.upperLeg.localRotation.slerp(new Quaternion(), 0.1); - this.lowerLeg.localRotation = this.lowerLeg.localRotation.slerp(new Quaternion(), 0.1); - this.foot.localRotation = this.foot.localRotation.slerp(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/4), 0.1); + this.upperLeg.localRotation = this.upperLeg.localRotation.slerp(identityRotation, 0.1); + this.lowerLeg.localRotation = this.lowerLeg.localRotation.slerp(identityRotation, 0.1); + this.foot.localRotation = this.foot.localRotation.slerp(downQuarterRotation, 0.1); // this.foot.position = footPosition; /* const direction = this.foot.position.sub(this.upperLeg.position).normalize().lerp(new Vector3(0, -1, 0), 0.1); const lowerLegPosition = this.upperLeg.position.add(direction.clone().multiplyScalar(upperLegLength)); @@ -227,7 +232,7 @@ class LegsManager { .decompose(position, quaternion, scale); this.leftLeg.foot.stickTransform.rotation = quaternion; } else { - this.leftLeg.foot.stickTransform.rotation = this.leftLeg.foot.rotation.multiply(new Quaternion().setFromUnitVectors(new Vector3(0, -1, 0), new Vector3(0, 0, 1)).inverse()); + this.leftLeg.foot.stickTransform.rotation = this.leftLeg.foot.rotation.multiply(upHalfRotation); } if (this.rightLeg.standing) { const rightFootEuler = new THREE.Euler().setFromQuaternion(rightFootRotation, 'YXZ'); @@ -244,7 +249,7 @@ class LegsManager { .decompose(position, quaternion, scale); this.rightLeg.foot.stickTransform.rotation = quaternion; } else { - this.rightLeg.foot.stickTransform.rotation = this.rightLeg.foot.rotation.multiply(new Quaternion().setFromUnitVectors(new Vector3(0, -1, 0), new Vector3(0, 0, 1)).inverse()); + this.rightLeg.foot.stickTransform.rotation = this.rightLeg.foot.rotation.multiply(upHalfRotation); } // position diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 5122cdd..4411603 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,7 +1,4 @@ -import {Vector3, Quaternion, Transform, GameObject, Mathf} from './Unity.js'; -import ShoulderTransforms from './ShoulderTransforms.js'; -import VRTrackingReferences from './VRTrackingReferences.js'; -import PoseManager from './PoseManager.js'; +import {Vector3, Quaternion, Transform, Mathf} from './Unity.js'; import VectorHelpers from './Utils/VectorHelpers.js'; const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); @@ -331,7 +328,7 @@ class ShoulderPoser } } - clampShoulderHandDistance() + /* clampShoulderHandDistance() { const leftHandVector = new Vector3().subVectors(this.avatarTrackingReferences.leftHand.position, this.shoulder.leftShoulderAnchor.position); const rightHandVector = new Vector3().subVectors(this.avatarTrackingReferences.rightHand.position, this.shoulder.rightShoulderAnchor.position); @@ -362,7 +359,7 @@ class ShoulderPoser { this.shoulder.rightArm.transform.localPosition = Vector3.zero; } - } + } */ } export default ShoulderPoser; From cf1b174146163200091d56af61387eea46678ea1 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:05:14 -0400 Subject: [PATCH 378/562] Legs manager dead code cleanup --- vrarmik/LegsManager.js | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 73d9ed8..4c881e5 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -31,7 +31,6 @@ class Leg { this.standing = true; this.poseManager = null; - // this.hmdTransformRef = null } Start() { @@ -137,32 +136,8 @@ class Leg { this.upperLeg.localRotation = this.upperLeg.localRotation.slerp(identityRotation, 0.1); this.lowerLeg.localRotation = this.lowerLeg.localRotation.slerp(identityRotation, 0.1); this.foot.localRotation = this.foot.localRotation.slerp(downQuarterRotation, 0.1); - // this.foot.position = footPosition; - /* const direction = this.foot.position.sub(this.upperLeg.position).normalize().lerp(new Vector3(0, -1, 0), 0.1); - const lowerLegPosition = this.upperLeg.position.add(direction.clone().multiplyScalar(upperLegLength)); - const footPosition = this.lowerLeg.position.add(direction.clone().multiplyScalar(lowerLegLength)); - - this.upperLeg.rotation = new Quaternion().setFromRotationMatrix( - new THREE.Matrix4().lookAt( - lowerLegPosition, - this.upperLeg.position, - new Vector3(0, 0, 1) - ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)); - this.lowerLeg.rotation = new Quaternion().setFromRotationMatrix( - new THREE.Matrix4().lookAt( - footPosition, - lowerLegPosition, - new Vector3(0, 0, 1) - ) - ).multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)); - this.foot.rotation = this.foot.rotation.slerp(new Quaternion(), 0.1); */ - - //this.lowerLeg.position = lowerLegPosition; - //this.foot.position = footPosition; */ this.standing = false; - // this.foot.stickTransform.position = this.foot.position; } } } @@ -181,7 +156,6 @@ class LegsManager { this.poseManager = rig.poseManager; this.leftLeg.poseManager = this.poseManager; this.rightLeg.poseManager = this.poseManager; - // this.hmdTransformRef = poseManager.vrTransforms.head; } Start() { From 897b4f504a7de2985391009b8b9affd86d93c3cf Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:05:41 -0400 Subject: [PATCH 379/562] More legs manager dead code cleanup --- vrarmik/LegsManager.js | 47 ------------------------------------------ 1 file changed, 47 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 4c881e5..e922985 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -41,53 +41,6 @@ class Leg { } Update() { - // const hipsDirection = new Vector3(0, 0, 1).applyQuaternion(this.transform.rotation); - // const hipsY = Math.atan2(hipsDirection.z, hipsDirection.x); - /* if (hipsY > Math.PI) { - hipsY -= Math.PI; - } - if (hipsY < Math.PI) { - hipsY += Math.PI; - } */ - - /* const upperLegDirection = new Vector3(0, 0, 1).applyQuaternion(this.upperLeg.rotation); - const upperLegY = Math.atan2(upperLegDirection.z, upperLegDirection.x); - const legDiff = this.foot.position.sub(this.transform.position); - const footEuler = new THREE.Euler(0, upperLegY - Math.PI/2, 0, 'YXZ'); */ - - /* const footEuler = new THREE.Euler().setFromQuaternion(this.foot.rotation.multiply(new Quaternion().setFromUnitVectors(new Vector3(0, -1, 0), new Vector3(0, 0, 1)).inverse()), 'YXZ'); - footEuler.x = 0; - footEuler.z = 0; */ - - /* let angleDiff = (() => { - let a = hipsY; - let b = upperLegY; - let d = _angleDiff(a, b); - return d; - })(); - if (this.left) { - angleDiff *= -1; - } - if (angleDiff < -Math.PI/3) { - if (this.left) { - // debugger; - // console.log('correct 1', hipsY, upperLegY, angleDiff); - // debugger; - footEuler.y += Math.PI/3; - } else { - footEuler.y -= Math.PI/3; - } - } else if (angleDiff > Math.PI/8) { - if (this.left) { - // debugger; - // console.log('correct 2', hipsY, upperLegY, angleDiff); - // debugger; - footEuler.y -= Math.PI/8; - } else { - footEuler.y += Math.PI/8; - } - } */ - const footPosition = this.foot.stickTransform.position; const {upperLegLength, lowerLegLength, legLength} = this; const g = this.upperLeg.position.add(footPosition.clone().sub(this.upperLeg.position).normalize().multiplyScalar(legLength)); From 478fe17723d9641fbdcea14a36c9bd3ecd66e6f5 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:10:20 -0400 Subject: [PATCH 380/562] Major arm transforms cleanup --- vrarmik/ArmTransforms.js | 91 ----------------------------------- vrarmik/ShoulderTransforms.js | 2 - 2 files changed, 93 deletions(-) diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js index ae69b94..2e63f42 100644 --- a/vrarmik/ArmTransforms.js +++ b/vrarmik/ArmTransforms.js @@ -6,102 +6,11 @@ class ArmTransforms this.transform = new Transform(); this.upperArm = new Transform(); this.lowerArm = new Transform(); - this.wrist1 = new Transform(); - this.wrist2 = new Transform(); this.hand = new Transform(); this.transform.AddChild(this.upperArm); this.upperArm.AddChild(this.lowerArm); - // this.lowerArm.AddChild(this.wrist1); - // this.lowerArm.AddChild(this.wrist2); this.lowerArm.AddChild(this.hand); - - this.armLengthByScale = false; - this.scaleAxis = Vector3.one; - this.scaleHandFactor = .7; - - this.poseManager = null; - } - - get upperArmLength() { - return this.distance(this.upperArm, this.lowerArm); - } - get lowerArmLength() { - const result = this.distance(this.lowerArm, this.hand); - /* console.log('lower arm length', result); - if (result !== 0) { - debugger; - } */ - return result; - } - get armLength() { - return this.upperArmLength + this.lowerArmLength; - } - - distance(a, b) { - return a.position.distanceTo(b.position); - } - - /* Start() - { - // PoseManager.Instance.onCalibrate += this.updateArmLengths; - // this.updateArmLengths(); - } */ - - updateArmLengths() - { - const shoulderWidth = new Vector3().subVectors(this.upperArm.position, this.lowerArm.position).magnitude; - const _armLength = (this.poseManager.playerWidthWrist - shoulderWidth) / 2; - this.setArmLength(_armLength); - } - - setUpperArmLength(length) - { - if (this.armLengthByScale) - { - const oldLowerArmLength = distance(this.lowerArm, this.hand); - - let newScale = new Vector3().subVectors(this.upperArm.localScale, this.scaleAxis.clone().multiplyScalar(Vector3.Scale(this.upperArm.localScale, this.scaleAxis).magnitude)); - const scaleFactor = Vector3.Scale(this.upperArm.localScale, this.scaleAxis).magnitude / upperArmLength * length; - newScale += this.scaleAxis * scaleFactor; - this.upperArm.localScale = newScale; - - this.setLowerArmLength(oldLowerArmLength); - } - else - { - const pos = this.lowerArm.localPosition; - pos.x = Mathf.Sign(pos.x) * length; - this.lowerArm.localPosition = pos; - } - } - - setLowerArmLength(length) - { - if (this.armLengthByScale) - { - } - else - { - const pos = this.hand.localPosition; - pos.x = Mathf.Sign(pos.x) * length; - this.hand.localPosition = pos; - } - } - - setArmLength(length) - { - const upperArmFactor = .48; - if (this.armLengthByScale) - { - this.upperArm.localScale = this.upperArm.localScale.clone().divideScalar(this.armLength).multiplyScalar(length); - this.hand.localScale = Vector3.one.divideScalar(1 - (1 - this.scaleHandFactor) * (1 - this.upperArm.localScale.x)); - } - else - { - this.setUpperArmLength(length * upperArmFactor); - this.setLowerArmLength(length * (1 - upperArmFactor)); - } } } diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index d4f65f3..cda3aeb 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -34,9 +34,7 @@ class ShoulderTransforms this.transform.AddChild(this.rightShoulderAnchor); this.leftArm = new ArmTransforms(); - this.leftArm.poseManager = rig.poseManager; this.rightArm = new ArmTransforms(); - this.rightArm.poseManager = rig.poseManager; this.leftShoulderAnchor.AddChild(this.leftArm.transform); this.rightShoulderAnchor.AddChild(this.rightArm.transform); From b03d6655ccc54380e583a484b66bcfe9e1b7fe21 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:14:04 -0400 Subject: [PATCH 381/562] Clean up VRArmIK initialization --- vrarmik/ShoulderTransforms.js | 31 ++----------------------------- vrarmik/VRArmIK.js | 8 ++++---- 2 files changed, 6 insertions(+), 33 deletions(-) diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js index cda3aeb..6e1f86a 100644 --- a/vrarmik/ShoulderTransforms.js +++ b/vrarmik/ShoulderTransforms.js @@ -2,7 +2,6 @@ import {Vector3, Transform} from './Unity.js'; import ArmTransforms from './ArmTransforms.js'; import ShoulderPoser from './ShoulderPoser.js'; import VRArmIK from './VRArmIK.js'; -import PoseManager from './PoseManager.js'; class ShoulderTransforms @@ -26,8 +25,6 @@ class ShoulderTransforms this.rightShoulder = new Transform(); this.transform.AddChild(this.rightShoulder); - /* this.leftShoulderRenderer = new Transform(); - this.rightShoulderRenderer = new Transform(); */ this.leftShoulderAnchor = new Transform(); this.transform.AddChild(this.leftShoulderAnchor); this.rightShoulderAnchor = new Transform(); @@ -41,24 +38,12 @@ class ShoulderTransforms this.shoulderPoser = new ShoulderPoser(rig, this); - this.leftArmIk = new VRArmIK(this.leftArm, true); - this.leftArmIk.shoulder = this; - this.leftArmIk.shoulderPoser = this.shoulderPoser; - this.leftArmIk.target = this.leftArmIk.shoulderPoser.avatarTrackingReferences.leftHand; - - this.rightArmIk = new VRArmIK(this.rightArm, false); - this.rightArmIk.shoulder = this; - this.rightArmIk.shoulderPoser = this.shoulderPoser; - this.rightArmIk.target = this.rightArmIk.shoulderPoser.avatarTrackingReferences.rightHand; + this.leftArmIk = new VRArmIK(this.leftArm, this, this.shoulderPoser, this.shoulderPoser.avatarTrackingReferences.leftHand, true); + this.rightArmIk = new VRArmIK(this.rightArm, this, this.shoulderPoser, this.shoulderPoser.avatarTrackingReferences.rightHand, false); } Start() { - // this.setShoulderWidth(PoseManager.Instance.playerWidthShoulders); - - // this.leftArm.Start(); - // this.rightArm.Start(); - // this.shoulderPoser.Start(); this.leftArmIk.Start(); this.rightArmIk.Start(); } @@ -68,18 +53,6 @@ class ShoulderTransforms this.leftArmIk.Update(); this.rightArmIk.Update(); } - - /* setShoulderWidth(width) - { - const localScale = new Vector3(width * .5, .05, .05); - const localPosition = new Vector3(width * .25, 0, 0); - - leftShoulderRenderer.localScale = localScale; - leftShoulderRenderer.localPosition = localPosition.clone().multiplyScalar(-1); - - rightShoulderRenderer.localScale = localScale; - rightShoulderRenderer.localPosition = localPosition; - } */ } export default ShoulderTransforms; diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js index 23ef249..da3695c 100644 --- a/vrarmik/VRArmIK.js +++ b/vrarmik/VRArmIK.js @@ -7,11 +7,11 @@ const bankRightRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1) class VRArmIK { - constructor(arm, left) { + constructor(arm, shoulder, shoulderPoser, target, left) { this.arm = arm; - this.shoulder = null; - this.shoulderPoser = null; - this.target = new Transform(); + this.shoulder = shoulder; + this.shoulderPoser = shoulderPoser; + this.target = target; this.left = left; this.upperArmLength = 0; From 43774b56fc898e93146773f4fa4726be599f9ebf Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:22:26 -0400 Subject: [PATCH 382/562] More legs manager optimization --- vrarmik/LegsManager.js | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index e922985..8cc0745 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -1,10 +1,15 @@ import {Vector2, Vector3, Quaternion, Transform} from './Unity.js'; +const zeroVector = new Vector3(); +const oneVector = new Vector3(1, 1, 1); const identityRotation = new Quaternion(); const downHalfRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2); const upHalfRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2); const downQuarterRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/4); +const localVector = new Vector3(); +const localMatrix = new THREE.Matrix4(); + const _mod = (a, n) => (a % n + n) % n; const _angleDiff = (targetA, sourceA) => { let a = targetA - sourceA; @@ -42,17 +47,16 @@ class Leg { Update() { const footPosition = this.foot.stickTransform.position; - const {upperLegLength, lowerLegLength, legLength} = this; - const g = this.upperLeg.position.add(footPosition.clone().sub(this.upperLeg.position).normalize().multiplyScalar(legLength)); + const g = this.upperLeg.position.add(footPosition.clone().sub(this.upperLeg.position).normalize().multiplyScalar(this.legLength)); if (g.y <= 0) { footPosition.y = 0; const footRotation = this.foot.stickTransform.rotation; - const hypotenuseDistance = upperLegLength; + const hypotenuseDistance = this.upperLegLength; const verticalDistance = Math.abs(this.upperLeg.position.y) / 2; const offsetDistance = hypotenuseDistance > verticalDistance ? Math.sqrt(hypotenuseDistance*hypotenuseDistance - verticalDistance*verticalDistance) : 0; const offsetDirection = footPosition.clone().sub(this.upperLeg.position) - .cross(new Vector3(1, 0, 0).applyQuaternion(footRotation)) + .cross(localVector.set(1, 0, 0).applyQuaternion(footRotation)) .normalize(); const lowerLegPosition = this.upperLeg.position.add(footPosition).divideScalar(2) @@ -60,20 +64,20 @@ class Leg { const upperLegDiff = this.upperLeg.position.sub(lowerLegPosition); const upperLegRotation = new Quaternion().setFromRotationMatrix( - new THREE.Matrix4().lookAt( - new Vector3(), + localMatrix.lookAt( + zeroVector, upperLegDiff, - new Vector3(0, 0, 1).applyQuaternion(footRotation) + localVector.set(0, 0, 1).applyQuaternion(footRotation) ) ).multiply(downHalfRotation); this.upperLeg.rotation = upperLegRotation; const lowerLegDiff = lowerLegPosition.clone().sub(footPosition); const lowerLegRotation = new Quaternion().setFromRotationMatrix( - new THREE.Matrix4().lookAt( - new Vector3(), + localMatrix.lookAt( + zeroVector, lowerLegDiff, - new Vector3(0, 0, 1).applyQuaternion(footRotation) + localVector.set(0, 0, 1).applyQuaternion(footRotation) ) ).multiply(downHalfRotation); this.lowerLeg.rotation = lowerLegRotation; @@ -124,19 +128,19 @@ class LegsManager { hipsFloorEuler.x = 0; hipsFloorEuler.z = 0; const hipsFloorRotation = new Quaternion().setFromEuler(hipsFloorEuler); - const planeMatrix = new THREE.Matrix4().compose(hipsFloorPosition, hipsFloorRotation, Vector3.one); + const planeMatrix = new THREE.Matrix4().compose(hipsFloorPosition, hipsFloorRotation, oneVector); const planeMatrixInverse = new THREE.Matrix4().getInverse(planeMatrix); const position = new Vector3(); const quaternion = new Quaternion(); const scale = new Vector3(); - new THREE.Matrix4().compose(this.leftLeg.foot.stickTransform.position, this.leftLeg.foot.stickTransform.rotation, Vector3.one) + localMatrix.compose(this.leftLeg.foot.stickTransform.position, this.leftLeg.foot.stickTransform.rotation, oneVector) .premultiply(planeMatrixInverse) .decompose(position, quaternion, scale); const leftFootPosition = position.clone(); const leftFootRotation = quaternion.clone(); - new THREE.Matrix4().compose(this.rightLeg.foot.stickTransform.position, this.rightLeg.foot.stickTransform.rotation, Vector3.one) + localMatrix.compose(this.rightLeg.foot.stickTransform.position, this.rightLeg.foot.stickTransform.rotation, oneVector) .premultiply(planeMatrixInverse) .decompose(position, quaternion, scale); const rightFootPosition = position.clone(); @@ -154,7 +158,7 @@ class LegsManager { if (leftFootEuler.y > Math.PI*0.15) { leftFootEuler.y = Math.PI*0.15; } - new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(leftFootEuler), Vector3.one) + localMatrix.compose(Vector3.zero, new Quaternion().setFromEuler(leftFootEuler), oneVector) .premultiply(planeMatrix) .decompose(position, quaternion, scale); this.leftLeg.foot.stickTransform.rotation = quaternion; @@ -171,7 +175,7 @@ class LegsManager { if (rightFootEuler.y > Math.PI*0.15) { rightFootEuler.y = Math.PI*0.15; } - new THREE.Matrix4().compose(Vector3.zero, new Quaternion().setFromEuler(rightFootEuler), Vector3.one) + localMatrix.compose(Vector3.zero, new Quaternion().setFromEuler(rightFootEuler), oneVector) .premultiply(planeMatrix) .decompose(position, quaternion, scale); this.rightLeg.foot.stickTransform.rotation = quaternion; From f3fc775c514bec4cb1f79a30fbc8c4409922ef62 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:33:24 -0400 Subject: [PATCH 383/562] Shoulder poser memory optimization --- vrarmik/ShoulderPoser.js | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 4411603..9028a71 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -3,6 +3,10 @@ import VectorHelpers from './Utils/VectorHelpers.js'; const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); +const localQuaternion = new Quaternion(); +const localQuaternion2 = new Quaternion(); +const localEuler = new THREE.Euler(); + class ShoulderPoser { constructor(rig, shoulder) { @@ -31,7 +35,7 @@ class ShoulderPoser this.startShoulderDislocationBefore = 0.005; - this.ignoreYPos = true; + // this.ignoreYPos = true; this.autoDetectHandsBehindHead = true; this.clampRotationToHead = true; this.enableDistinctShoulderRotation = true; @@ -95,15 +99,14 @@ class ShoulderPoser } updateHips() { - const hmdPosition = this.vrTrackingReferences.head.position; const hmdRotation = this.vrTrackingReferences.head.rotation; hmdRotation.multiply(z180Quaternion); - const hmdEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); + const hmdEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ'); hmdEuler.x = 0; hmdEuler.z = 0; - const hmdFlatRotation = new Quaternion().setFromEuler(hmdEuler); + const hmdFlatRotation = localQuaternion.setFromEuler(hmdEuler); - const headPosition = hmdPosition.clone().add(this.shoulder.eyes.localPosition.multiplyScalar(-1).applyQuaternion(hmdRotation)); + const headPosition = this.vrTrackingReferences.head.position.add(this.shoulder.eyes.localPosition.multiplyScalar(-1).applyQuaternion(hmdRotation)); const neckPosition = headPosition.clone().add(this.shoulder.head.localPosition.multiplyScalar(-1).applyQuaternion(hmdRotation)); const chestPosition = neckPosition.clone().add(this.shoulder.neck.localPosition.multiplyScalar(-1).applyQuaternion(hmdFlatRotation)); const spinePosition = chestPosition.clone().add(this.shoulder.transform.localPosition.multiplyScalar(-1).applyQuaternion(hmdFlatRotation)); @@ -116,16 +119,15 @@ class ShoulderPoser } updateNeck() { - // const hmdPosition = this.vrTrackingReferences.head.position; const hmdRotation = this.vrTrackingReferences.head.rotation; hmdRotation.multiply(z180Quaternion); - const hmdFlatEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); + const hmdFlatEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ'); hmdFlatEuler.x = 0; hmdFlatEuler.z = 0; - const hmdFlatRotation = new Quaternion().setFromEuler(hmdFlatEuler); - const hmdUpEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); + const hmdFlatRotation = localQuaternion.setFromEuler(hmdFlatEuler); + const hmdUpEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ'); hmdUpEuler.y = 0; - const hmdUpRotation = new Quaternion().setFromEuler(hmdUpEuler); + const hmdUpRotation = localQuaternion2.setFromEuler(hmdUpEuler); this.shoulder.neck.localRotation = hmdFlatRotation.clone().premultiply(this.shoulder.transform.rotation.inverse()); this.shoulder.head.localRotation = hmdUpRotation; @@ -236,11 +238,11 @@ class ShoulderPoser const distanceLeftHand = new Vector3().subVectors(leftHand.position, this.shoulder.transform.position); const distanceRightHand = new Vector3().subVectors(rightHand.position, this.shoulder.transform.position); - if (this.ignoreYPos) - { + /* if (this.ignoreYPos) + { */ distanceLeftHand.y = 0; distanceRightHand.y = 0; - } + // } const hmdRotation = this.vrTrackingReferences.head.rotation; const hmdEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); From d56acbecd8fe2f4ab6235f1ca494297a5f6929a4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:47:22 -0400 Subject: [PATCH 384/562] Major shoulder poser optimization --- vrarmik/ShoulderPoser.js | 85 ++++++++++++++++++++-------------------- 1 file changed, 42 insertions(+), 43 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 9028a71..7b12f86 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -1,6 +1,7 @@ import {Vector3, Quaternion, Transform, Mathf} from './Unity.js'; import VectorHelpers from './Utils/VectorHelpers.js'; +const upVector = new THREE.Vector3(0, 1, 0); const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); const localQuaternion = new Quaternion(); @@ -21,32 +22,32 @@ class ShoulderPoser this.maxDeltaHeadRotation = 80; - this.distinctShoulderRotationLimitForward = 33; + // this.distinctShoulderRotationLimitForward = 33; - this.distinctShoulderRotationLimitBackward = 0; + // this.distinctShoulderRotationLimitBackward = 0; - this.distinctShoulderRotationLimitUpward = 33; - this.distinctShoulderRotationMultiplier = 30; + // this.distinctShoulderRotationLimitUpward = 33; + // this.distinctShoulderRotationMultiplier = 30; - this.rightRotationStartHeight = 0; - this.rightRotationHeightFactor = 142; - this.rightRotationHeadRotationFactor = 0.3; - this.rightRotationHeadRotationOffset = -20; + // this.rightRotationStartHeight = 0; + // this.rightRotationHeightFactor = 142; + // this.rightRotationHeadRotationFactor = 0.3; + // this.rightRotationHeadRotationOffset = -20; - this.startShoulderDislocationBefore = 0.005; + // this.startShoulderDislocationBefore = 0.005; // this.ignoreYPos = true; - this.autoDetectHandsBehindHead = true; - this.clampRotationToHead = true; - this.enableDistinctShoulderRotation = true; - this.enableShoulderDislocation = true; + // this.autoDetectHandsBehindHead = true; + // this.clampRotationToHead = true; + // this.enableDistinctShoulderRotation = true; + // this.enableShoulderDislocation = true; - this.handsBehindHead = false; + // this.handsBehindHead = false; - this.clampingHeadRotation = false; - this.shoulderDislocated = false; - this.shoulderRightRotation; + // this.clampingHeadRotation = false; + // this.shoulderDislocated = false; + // this.shoulderRightRotation; // this.lastAngle = Vector3.zero; @@ -73,9 +74,7 @@ class ShoulderPoser // this.shoulder.transform.rotation = Quaternion.identity; // this.positionShoulder(); - let rotation = this.rotateShoulderUpBase(); - rotation = this.rotateShoulderRightBase(rotation); - this.shoulder.transform.rotation = rotation; + this.rotateShoulderBase(); /* if (this.enableDistinctShoulderRotation) { @@ -167,38 +166,37 @@ class ShoulderPoser targetAngle.multiplyScalar(angleSign); shoulderSide.localRotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(targetAngle.x * Mathf.Deg2Rad, targetAngle.y * Mathf.Deg2Rad, targetAngle.z * Mathf.Deg2Rad, Mathf.Order)); - } */ - + } positionShoulder() { - /* const headNeckOffset = this.headNeckDirectionVector.clone().applyQuaternion(this.avatarTrackingReferences.head.rotation); + const headNeckOffset = this.headNeckDirectionVector.clone().applyQuaternion(this.avatarTrackingReferences.head.rotation); const targetPosition = new Vector3().addVectors(this.avatarTrackingReferences.head.position, headNeckOffset.clone().multiplyScalar(this.headNeckDistance)); this.shoulder.transform.localPosition = - new Vector3().addVectors(targetPosition, this.neckShoulderDistance); */ - } + new Vector3().addVectors(targetPosition, this.neckShoulderDistance); + } */ - rotateShoulderUpBase() + rotateShoulderBase() { - const angle = this.getCombinedDirectionAngleUp(); + let angleY = this.getCombinedDirectionAngleUp(); - const targetRotation = new Vector3(0, angle, 0); + // const targetRotation = new Vector3(0, angle, 0); /* if (this.autoDetectHandsBehindHead) { this.detectHandsBehindHead(targetRotation); } */ - if (this.clampRotationToHead) - { - this.clampHeadRotationDeltaUp(targetRotation); - } + /* if (this.clampRotationToHead) + { */ + angleY = this.clampHeadRotationDeltaUp(angleY); + // } // this.shoulder.transform.eulerAngles = targetRotation; - return new THREE.Quaternion().setFromEuler(new THREE.Euler(targetRotation.x * Mathf.Deg2Rad, targetRotation.y * Mathf.Deg2Rad, targetRotation.z * Mathf.Deg2Rad, Mathf.Order)) + this.shoulder.transform.rotation = localQuaternion.setFromEuler(localEuler.set(0, angleY * Mathf.Deg2Rad, 0, Mathf.Order)) } - rotateShoulderRightBase(rotation) + /* rotateShoulderRightBase(rotation) { const heightDiff = this.vrTrackingReferences.head.position.y - this.poseManager.vrSystemOffsetHeight; @@ -221,7 +219,7 @@ class ShoulderPoser // this.shoulder.transform.rotation = new Quaternion().multiplyQuaternions(deltaRot, this.shoulder.transform.rotation); return new Quaternion().multiplyQuaternions(deltaRot, rotation); // this.positionShoulderRelative(); - } + } */ /* positionShoulderRelative() { @@ -305,29 +303,30 @@ class ShoulderPoser } } */ - clampHeadRotationDeltaUp(targetRotation) + clampHeadRotationDeltaUp(angleY) { const hmdRotation = this.vrTrackingReferences.head.rotation; hmdRotation.multiply(z180Quaternion); const headUpRotation = (Transform.eulerAngles(hmdRotation).y + 360) % 360; - const targetUpRotation = (targetRotation.y + 360) % 360; + const targetUpRotation = (angleY + 360) % 360; const delta = headUpRotation - targetUpRotation; if (delta > this.maxDeltaHeadRotation && delta < 180 || delta < -180 && delta >= -360 + this.maxDeltaHeadRotation) { - targetRotation.y = headUpRotation - this.maxDeltaHeadRotation; - this.clampingHeadRotation = true; + angleY = headUpRotation - this.maxDeltaHeadRotation; + // this.clampingHeadRotation = true; } else if (delta < -this.maxDeltaHeadRotation && delta > -180 || delta > 180 && delta < 360 - this.maxDeltaHeadRotation) { - targetRotation.y = headUpRotation + this.maxDeltaHeadRotation; - this.clampingHeadRotation = true; + angleY = headUpRotation + this.maxDeltaHeadRotation; + // this.clampingHeadRotation = true; } - else + /* else { this.clampingHeadRotation = false; - } + } */ + return angleY; } /* clampShoulderHandDistance() From be3993dcae8d65dd0e21e38e19aab2f431492bdb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:52:16 -0400 Subject: [PATCH 385/562] More shoulder poser memory optimization --- vrarmik/ShoulderPoser.js | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index 7b12f86..c4b9077 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -4,6 +4,10 @@ import VectorHelpers from './Utils/VectorHelpers.js'; const upVector = new THREE.Vector3(0, 1, 0); const z180Quaternion = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI); +const localVector = new THREE.Vector3(); +const localVector2 = new THREE.Vector3(); +const localVector3 = new THREE.Vector3(); +const localVector4 = new THREE.Vector3(); const localQuaternion = new Quaternion(); const localQuaternion2 = new Quaternion(); const localEuler = new THREE.Euler(); @@ -233,8 +237,8 @@ class ShoulderPoser const leftHand = this.avatarTrackingReferences.leftHand; const rightHand = this.avatarTrackingReferences.rightHand; - const distanceLeftHand = new Vector3().subVectors(leftHand.position, this.shoulder.transform.position); - const distanceRightHand = new Vector3().subVectors(rightHand.position, this.shoulder.transform.position); + const distanceLeftHand = localVector.subVectors(leftHand.position, this.shoulder.transform.position); + const distanceRightHand = localVector2.subVectors(rightHand.position, this.shoulder.transform.position); /* if (this.ignoreYPos) { */ @@ -243,15 +247,15 @@ class ShoulderPoser // } const hmdRotation = this.vrTrackingReferences.head.rotation; - const hmdEuler = new THREE.Euler().setFromQuaternion(hmdRotation, 'YXZ'); + const hmdEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ'); hmdEuler.x = 0; hmdEuler.z = 0; - const hmdFlatRotation = new Quaternion().setFromEuler(hmdEuler); + const hmdFlatRotation = localQuaternion.setFromEuler(hmdEuler); const hmdFlatRotationInverse = hmdFlatRotation.clone().inverse(); - const leftHandBehind = distanceLeftHand.clone().applyQuaternion(hmdFlatRotationInverse); + const leftHandBehind = localVector3.copy(distanceLeftHand).applyQuaternion(hmdFlatRotationInverse); const leftBehind = leftHandBehind.z > 0; - const rightHandBehind = distanceRightHand.clone().applyQuaternion(hmdFlatRotationInverse); + const rightHandBehind = localVector4.copy(distanceRightHand).applyQuaternion(hmdFlatRotationInverse); const rightBehind = rightHandBehind.z > 0; if (leftBehind) { @@ -277,10 +281,10 @@ class ShoulderPoser distanceRightHand.add(rightHandBehind); } - const directionLeftHand = distanceLeftHand.normalized; - const directionRightHand = distanceRightHand.normalized; + const directionLeftHand = distanceLeftHand.normalize(); + const directionRightHand = distanceRightHand.normalize(); - const combinedDirection = new Vector3().addVectors(directionLeftHand, directionRightHand); + const combinedDirection = localVector.addVectors(directionLeftHand, directionRightHand); // console.log('combined', Mathf.Atan2(combinedDirection.x, combinedDirection.z) * 180 / Mathf.PI, combinedDirection.x, combinedDirection.z); From 0e84440454a9434f994c9dfc8a7cd6ae6d17f151 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:54:41 -0400 Subject: [PATCH 386/562] More shoulder poser optimization --- vrarmik/ShoulderPoser.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js index c4b9077..d4d7080 100644 --- a/vrarmik/ShoulderPoser.js +++ b/vrarmik/ShoulderPoser.js @@ -311,7 +311,8 @@ class ShoulderPoser { const hmdRotation = this.vrTrackingReferences.head.rotation; hmdRotation.multiply(z180Quaternion); - const headUpRotation = (Transform.eulerAngles(hmdRotation).y + 360) % 360; + + const headUpRotation = (localEuler.setFromQuaternion(hmdRotation, 'YXZ').y * Mathf.Rad2Deg + 360) % 360; const targetUpRotation = (angleY + 360) % 360; const delta = headUpRotation - targetUpRotation; From ef0f1892c5327320a8959d8b424ae238388069c3 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:58:00 -0400 Subject: [PATCH 387/562] Remove dead flipY latch --- vrarmik/PoseManager.js | 2 -- vrarmik/Rig.js | 1 - 2 files changed, 3 deletions(-) diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 73976d3..39fead1 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -22,8 +22,6 @@ class PoseManager this.playerWidthShoulders = 0.31; this.loadPlayerSizeOnAwake = false; - this.flipY = false; - // PoseManager.Instance = this; } diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 908c464..0413ddc 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -598,7 +598,6 @@ class Rig { }; this.poseManager = new PoseManager(this); - this.poseManager.flipY = flipY; this.shoulderTransforms = new ShoulderTransforms(this); this.legsManager = new LegsManager(this); From e28be2acaf5d09581220667dbb8eb70b7793cccf Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 04:58:23 -0400 Subject: [PATCH 388/562] More pose manager cleanup --- vrarmik/PoseManager.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js index 39fead1..bcff887 100644 --- a/vrarmik/PoseManager.js +++ b/vrarmik/PoseManager.js @@ -13,7 +13,7 @@ class PoseManager // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. // In OpenVR, the 0 position is the ground position and the user is then at (0, playerHeightHmd, 0) if he is in the middle of the room, so I need to correct this for shoulder calculation - this.vrSystemOffsetHeight = 0.0; + // this.vrSystemOffsetHeight = 0.0; this.referencePlayerHeightHmd = 1.7; this.referencePlayerWidthWrist = 1.39; @@ -43,7 +43,7 @@ class PoseManager { this.loadPlayerSize(); } - this.vrSystemOffsetHeight = 0; + // this.vrSystemOffsetHeight = 0; } /* Start() From e5b72853991fb0c2cf43a7283cbf1803aefd73a4 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 05:10:03 -0400 Subject: [PATCH 389/562] Bugfix Rig premultiplies --- vrarmik/Rig.js | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 0413ddc..d90f791 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -720,12 +720,12 @@ class Rig { if (['Left_leg'].includes(k)) { modelBone.quaternion - .multiply(modelBoneOutput.localRotation) + .premultiply(modelBoneOutput.localRotation) // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) } if (['Left_knee'].includes(k)) { modelBone.quaternion - .multiply(modelBoneOutput.localRotation) + .premultiply(modelBoneOutput.localRotation) // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) } if (['Left_ankle'].includes(k)) { @@ -736,12 +736,12 @@ class Rig { if (['Right_leg'].includes(k)) { modelBone.quaternion - .multiply(modelBoneOutput.localRotation) + .premultiply(modelBoneOutput.localRotation) // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) } if (['Right_knee'].includes(k)) { modelBone.quaternion - .multiply(modelBoneOutput.localRotation) + .premultiply(modelBoneOutput.localRotation) // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) } if (['Right_ankle'].includes(k)) { @@ -752,7 +752,7 @@ class Rig { if (['Left_shoulder'].includes(k)) { modelBone.quaternion - .multiply(modelBoneOutput.localRotation) + .premultiply(modelBoneOutput.localRotation) } if (['Left_arm'].includes(k)) { modelBone.quaternion @@ -775,7 +775,7 @@ class Rig { if (['Right_shoulder'].includes(k)) { modelBone.quaternion - .multiply(modelBoneOutput.localRotation) + .premultiply(modelBoneOutput.localRotation) } if (['Right_arm'].includes(k)) { modelBone.quaternion From e5bfb92b90d9bf0d55083bbe747cd583a3d578fb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 05:19:10 -0400 Subject: [PATCH 390/562] Optimize Rig.js main loop --- vrarmik/Rig.js | 100 ++++++------------------------------------------- 1 file changed, 12 insertions(+), 88 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index d90f791..4413b7e 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -4,6 +4,10 @@ import PoseManager from './PoseManager.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import LegsManager from './LegsManager.js'; +const upRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2); +const leftRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2); +const rightRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2); + const _localizeMatrixWorld = bone => { bone.matrix.copy(bone.matrixWorld); if (bone.parent) { @@ -706,94 +710,14 @@ class Rig { if (k === 'Hips') { modelBone.position.copy(modelBoneOutput.position).multiplyScalar(this.scaleFactor); } - modelBone.quaternion - .copy(modelBone.initialQuaternion) - - if (['Hips', 'Spine', 'Chest', 'Neck', 'Head'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - } - /* if (k === 'Hips') { - modelBone.quaternion - .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) - } */ - - if (['Left_leg'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) - } - if (['Left_knee'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) - } - if (['Left_ankle'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)) - } - - if (['Right_leg'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/2)) - } - if (['Right_knee'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - // .premultiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI)) - } - if (['Right_ankle'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2)) - } - - if (['Left_shoulder'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - } - if (['Left_arm'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // forward - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI*0.6)) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI/8)) // down - } - if (['Left_elbow'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - } - if (['Left_wrist'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2)) // center - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up - } - - if (['Right_shoulder'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - } - if (['Right_arm'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // forward - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI*0.6)) - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/4)) // up - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), Math.PI/8)) // down - } - if (['Right_elbow'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - } - if (['Right_wrist'].includes(k)) { - modelBone.quaternion - .premultiply(modelBoneOutput.localRotation) - .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2)) // center - // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI/8)) // up + modelBone.quaternion.multiplyQuaternions(modelBoneOutput.localRotation, modelBone.initialQuaternion) + + if (k === 'Left_ankle' || k === 'Right_ankle') { + modelBone.quaternion.multiply(upRotation); + } else if (k === 'Left_wrist') { + modelBone.quaternion.multiply(leftRotation); // center + } else if (k === 'Right_wrist') { + modelBone.quaternion.multiply(rightRotation); // center } modelBone.updateMatrixWorld(); } From 492646c87ebc01f2435e978f80a0410a98ed40d5 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 05:40:06 -0400 Subject: [PATCH 391/562] Clean up vrarmik.html --- vrarmik.html | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 10d44b2..184db1e 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -878,18 +878,19 @@

Multiplayer

.multiply(new Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.2)) .multiply(new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.25)); - rig.inputs.rightGamepad.rotation = new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle); - rig.inputs.rightGamepad.position = new Vector3(positionOffset, rig.height*0.7, 0).add( - new Vector3(-rig.shoulderWidth/2, 0, 0).applyQuaternion(rig.inputs.rightGamepad.rotation) - ).add( - new Vector3(-0.1, 0, -1).normalize().multiplyScalar(rig.rightArmLength*0.7).applyQuaternion(rig.inputs.rightGamepad.rotation) - ); + rig.inputs.rightGamepad.rotation = new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle) + // .multiply(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.sin((realDateNow()%5000)/5000*Math.PI*2)*Math.PI*0.6)); + rig.inputs.rightGamepad.position = new Vector3(positionOffset, rig.height*0.7 + Math.sin((realDateNow()%2000)/2000*Math.PI*2)*0.1, 0).add( + new Vector3(-rig.shoulderWidth/2, 0, -0.2).applyQuaternion(rig.inputs.rightGamepad.rotation) + )/*.add( + new Vector3(-0.1, 0, -1).normalize().multiplyScalar(rig.rightArmLength*0.4).applyQuaternion(rig.inputs.rightGamepad.rotation) + ); */ rig.inputs.leftGamepad.rotation = new Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle); rig.inputs.leftGamepad.position = new Vector3(positionOffset, rig.height*0.7, 0).add( - new Vector3(rig.shoulderWidth/2, 0, 0).applyQuaternion(rig.inputs.leftGamepad.rotation) - ).add( - new Vector3(0.1, 0, -1).normalize().multiplyScalar(rig.leftArmLength*0.7).applyQuaternion(rig.inputs.leftGamepad.rotation) - ); + new Vector3(rig.shoulderWidth/2, 0, -0.2).applyQuaternion(rig.inputs.leftGamepad.rotation) + )/*.add( + new Vector3(0.1, 0, -1).normalize().multiplyScalar(rig.leftArmLength*0.4).applyQuaternion(rig.inputs.leftGamepad.rotation) + );*/ rig.inputs.leftGamepad.pointer = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2; rig.inputs.leftGamepad.grip = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2; From 59919d7d1e1c1b83d53a4766255a316c27b2ee05 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 05:40:22 -0400 Subject: [PATCH 392/562] Major Rig.js main loop memory optimization --- vrarmik/Rig.js | 59 +++++++++++++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 25 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 4413b7e..f03d9b9 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -4,10 +4,20 @@ import PoseManager from './PoseManager.js'; import ShoulderTransforms from './ShoulderTransforms.js'; import LegsManager from './LegsManager.js'; +const zeroVector = new Vector3(); +const oneVector = new Vector3(1, 1, 1); const upRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI/2); const leftRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2); const rightRotation = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2); +const localVector = new Vector3(); +const localVector2 = new Vector3(); +const localVector3 = new Vector3(); +const localVector4 = new Vector3(); +const localQuaternion = new Quaternion(); +const localQuaternion2 = new Quaternion(); +const localMatrix = new THREE.Matrix4(); + const _localizeMatrixWorld = bone => { bone.matrix.copy(bone.matrixWorld); if (bone.parent) { @@ -733,20 +743,15 @@ class Rig { for (const k in fingerBones) { const fingerBone = fingerBones[k]; if (fingerBone) { - const axis = new Vector3(); - let angle; if (k === 'thumb') { - axis.set(0, left ? 1 : -1, 0); - angle = gamepadInput.grip * Math.PI*0.25; + localQuaternion.setFromAxisAngle(localVector.set(0, left ? 1 : -1, 0), gamepadInput.grip * Math.PI*0.25); } else if (k === 'index') { - axis.set(0, 0, left ? -1 : 1); - angle = gamepadInput.pointer * Math.PI*0.5; + localQuaternion.setFromAxisAngle(localVector.set(0, 0, left ? -1 : 1), gamepadInput.pointer * Math.PI*0.5); } else { - axis.set(0, 0, left ? -1 : 1); - angle = gamepadInput.grip * Math.PI*0.5; + localQuaternion.setFromAxisAngle(localVector.set(0, 0, left ? -1 : 1), gamepadInput.grip * Math.PI*0.5); } fingerBone.traverse(subFingerBone => { - subFingerBone.quaternion.setFromAxisAngle(axis, angle); + subFingerBone.quaternion.copy(localQuaternion); }); } } @@ -756,18 +761,19 @@ class Rig { } if (this.options.hair) { + const hipsRotation = this.modelBones.Hips.quaternion; const _processHairBone = (hairBone, children) => { - const p = new Vector3().setFromMatrixPosition(hairBone.matrixWorld); + const p = localVector.setFromMatrixPosition(hairBone.matrixWorld); for (let i = 0; i < children.length; i++) { const childHairBone = children[i]; - const px = new Vector3().setFromMatrixPosition(childHairBone.matrixWorld); + const px = localVector2.setFromMatrixPosition(childHairBone.matrixWorld); const hairDistance = px.distanceTo(p); - const hairDirection = px.clone().sub(p).normalize(); + const hairDirection = localVector3.copy(px).sub(p).normalize(); if (hairDistance > childHairBone.length * 2) { - px.copy(p).add(hairDirection.clone().multiplyScalar(childHairBone.length * 2)); + px.copy(p).add(localVector4.copy(hairDirection).multiplyScalar(childHairBone.length * 2)); } const l = childHairBone.velocity.length(); @@ -775,21 +781,24 @@ class Rig { childHairBone.velocity.multiplyScalar(0.05/l); } - childHairBone.velocity.add(hairDirection.clone().multiplyScalar(-(hairDistance - childHairBone.length) * 0.1 * timeDiff/32)); - childHairBone.velocity.add(new Vector3(0, -9.8, 0).multiplyScalar(0.0002 * timeDiff/32)); - childHairBone.velocity.add(childHairBone.worldParentOffset.clone().applyQuaternion(this.modelBones.Hips.quaternion).multiplyScalar(0.03 * timeDiff/32)); - childHairBone.velocity.lerp(new Vector3(), 0.2 * timeDiff/32); + childHairBone.velocity.add(localVector4.copy(hairDirection).multiplyScalar(-(hairDistance - childHairBone.length) * 0.1 * timeDiff/32)); + childHairBone.velocity.add(localVector4.set(0, -9.8, 0).multiplyScalar(0.0002 * timeDiff/32)); + childHairBone.velocity.add(localVector4.copy(childHairBone.worldParentOffset).applyQuaternion(hipsRotation).multiplyScalar(0.03 * timeDiff/32)); + childHairBone.velocity.lerp(zeroVector, 0.2 * timeDiff/32); - const p2 = px.clone().add(childHairBone.velocity.clone().multiplyScalar(1)); - const q2 = childHairBone.initialWorldQuaternion.clone().premultiply( - new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( - new Vector3(0, 0, 0), + const p2 = px.clone().add(childHairBone.velocity); + const q2 = localQuaternion.multiplyQuaternions( + localQuaternion2.setFromRotationMatrix(localMatrix.lookAt( + zeroVector, hairDirection, - new Vector3(0, 0, -1).applyQuaternion(this.modelBones.Hips.quaternion), - )) + localVector4.set(0, 0, -1).applyQuaternion(hipsRotation), + )), + childHairBone.initialWorldQuaternion ); - const s2 = new Vector3(1, 1, 1); - childHairBone.matrixWorld.compose(p2, q2, s2); + childHairBone.matrixWorld.compose(p2, q2, oneVector); + } + for (let i = 0; i < children.length; i++) { + const childHairBone = children[i]; _processHairBone(childHairBone, childHairBone.children); } }; From efe7fb448b182b4f3b7cae958f78b5a699566943 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 05:48:29 -0400 Subject: [PATCH 393/562] More legs manager memory optimization --- vrarmik/LegsManager.js | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js index 8cc0745..fbf82c9 100644 --- a/vrarmik/LegsManager.js +++ b/vrarmik/LegsManager.js @@ -8,7 +8,11 @@ const upHalfRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), M const downQuarterRotation = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI/4); const localVector = new Vector3(); +const localQuaternion = new Quaternion(); +const localEuler = new THREE.Euler(); const localMatrix = new THREE.Matrix4(); +const localMatrix2 = new THREE.Matrix4(); +const localMatrix3 = new THREE.Matrix4(); const _mod = (a, n) => (a % n + n) % n; const _angleDiff = (targetA, sourceA) => { @@ -124,23 +128,22 @@ class LegsManager { Update() { const hipsFloorPosition = this.hips.position; hipsFloorPosition.y = 0; - const hipsFloorEuler = new THREE.Euler().setFromQuaternion(this.hips.rotation, 'YXZ'); + const hipsFloorEuler = localEuler.setFromQuaternion(this.hips.rotation, 'YXZ'); hipsFloorEuler.x = 0; hipsFloorEuler.z = 0; - const hipsFloorRotation = new Quaternion().setFromEuler(hipsFloorEuler); - const planeMatrix = new THREE.Matrix4().compose(hipsFloorPosition, hipsFloorRotation, oneVector); - const planeMatrixInverse = new THREE.Matrix4().getInverse(planeMatrix); + const planeMatrix = localMatrix.compose(hipsFloorPosition, localQuaternion.setFromEuler(hipsFloorEuler), oneVector); + const planeMatrixInverse = localMatrix2.getInverse(planeMatrix); const position = new Vector3(); const quaternion = new Quaternion(); const scale = new Vector3(); - localMatrix.compose(this.leftLeg.foot.stickTransform.position, this.leftLeg.foot.stickTransform.rotation, oneVector) + localMatrix3.compose(this.leftLeg.foot.stickTransform.position, this.leftLeg.foot.stickTransform.rotation, oneVector) .premultiply(planeMatrixInverse) .decompose(position, quaternion, scale); const leftFootPosition = position.clone(); const leftFootRotation = quaternion.clone(); - localMatrix.compose(this.rightLeg.foot.stickTransform.position, this.rightLeg.foot.stickTransform.rotation, oneVector) + localMatrix3.compose(this.rightLeg.foot.stickTransform.position, this.rightLeg.foot.stickTransform.rotation, oneVector) .premultiply(planeMatrixInverse) .decompose(position, quaternion, scale); const rightFootPosition = position.clone(); @@ -149,7 +152,7 @@ class LegsManager { // rotation if (this.leftLeg.standing) { - const leftFootEuler = new THREE.Euler().setFromQuaternion(leftFootRotation, 'YXZ'); + const leftFootEuler = localEuler.setFromQuaternion(leftFootRotation, 'YXZ'); leftFootEuler.x = 0; leftFootEuler.z = 0; if (leftFootEuler.y < -Math.PI*0.15) { @@ -158,7 +161,7 @@ class LegsManager { if (leftFootEuler.y > Math.PI*0.15) { leftFootEuler.y = Math.PI*0.15; } - localMatrix.compose(Vector3.zero, new Quaternion().setFromEuler(leftFootEuler), oneVector) + localMatrix3.compose(zeroVector, localQuaternion.setFromEuler(leftFootEuler), oneVector) .premultiply(planeMatrix) .decompose(position, quaternion, scale); this.leftLeg.foot.stickTransform.rotation = quaternion; @@ -166,7 +169,7 @@ class LegsManager { this.leftLeg.foot.stickTransform.rotation = this.leftLeg.foot.rotation.multiply(upHalfRotation); } if (this.rightLeg.standing) { - const rightFootEuler = new THREE.Euler().setFromQuaternion(rightFootRotation, 'YXZ'); + const rightFootEuler = localEuler.setFromQuaternion(rightFootRotation, 'YXZ'); rightFootEuler.x = 0; rightFootEuler.z = 0; if (rightFootEuler.y < -Math.PI*0.15) { @@ -175,7 +178,7 @@ class LegsManager { if (rightFootEuler.y > Math.PI*0.15) { rightFootEuler.y = Math.PI*0.15; } - localMatrix.compose(Vector3.zero, new Quaternion().setFromEuler(rightFootEuler), oneVector) + localMatrix3.compose(zeroVector, localQuaternion.setFromEuler(rightFootEuler), oneVector) .premultiply(planeMatrix) .decompose(position, quaternion, scale); this.rightLeg.foot.stickTransform.rotation = quaternion; From 9a1c080aa606288c48087a57d140d6b0fa436ffb Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 17:29:28 -0400 Subject: [PATCH 394/562] Fall back to lookup filesystem resoures based on extension --- vrarmik.html | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 184db1e..2065226 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -425,17 +425,27 @@

Multiplayer

const match = pathname.match(/([^\/]+)$/); return match && match[1]; }; +const _filename2Ext = filename => { + const match = filename.match(/\.([^\.]+)$/); + return match ? match[1] : null; +}; const _loadModelFilesystem = async filesystem => { const manager = new THREE.LoadingManager(); manager.setURLModifier(url => { - // console.log('load url', url); const match = url.match(/([^\/]+)$/); if (match) { const filename = match[1]; const file = filesystem.find(file => file.filename === filename); if (file) { - // console.log('replace url', url, file.url); url = file.url; + } else { + const ext = _filename2Ext(filename); + if (ext) { + const file = filesystem.find(file => file.ext === ext); + if (file) { + url = file.url; + } + } } } return url; @@ -515,6 +525,7 @@

Multiplayer

const entry = entries[i]; const pathname = entry.filename; const filename = _pathname2Filename(pathname); + const ext = _filename2Ext(filename); const blob = await new Promise((accept, reject) => { entry.getData(new zip.BlobWriter('application/octet-stream'), function(blob) { accept(blob); @@ -526,6 +537,7 @@

Multiplayer

filesystem.push({ pathname, filename, + ext, url, }); // console.log('got blob', entry, blob, pathname, filename, url); From 5d9160a6accdd96281c70d15b52c5aa220709add Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 17:29:52 -0400 Subject: [PATCH 395/562] Add model post-patch support --- vrarmik.html | 15 +++++++++++++++ vrarmik/Rig.js | 3 --- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index 2065226..b65fbe8 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -496,6 +496,17 @@

Multiplayer

reader.onerror = reject; reader.readAsArrayBuffer(blob); }); +const _patchModel = model => { + model.traverse(o => { + if (o.isMesh) { + o.frustumCulled = false; + + if (o.material.opacity === 0) { + o.material.opacity = 1; + } + } + }); +}; const _loadModelUrl = async (href, filename = href) => { const fileType = _getFileType(filename); if (fileType === 'gltf') { @@ -504,11 +515,13 @@

Multiplayer

accept(object.scene); }, xhr => {}, reject); }); + _patchModel(model); return model; } else if (fileType === 'fbx') { const model = await new Promise((accept, reject) => { new THREE.FBXLoader().load(href, accept, xhr => {}, reject); }); + _patchModel(model); return model; } else if (fileType === 'zip') { const unitypackageRes = await fetch(href); @@ -545,6 +558,7 @@

Multiplayer

// console.log('got filesystem', filesystem); const model = await _loadModelFilesystem(filesystem); + _patchModel(model); return model; } else if (fileType === 'tgz') { const unitypackageRes = await fetch(href); @@ -576,6 +590,7 @@

Multiplayer

} } const model = await _loadModelFilesystem(filesystem); + _patchModel(model); return model; } else { throw new Error(`unknown file type: ${filename} (${fileType})`); diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index f03d9b9..ca6a5da 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -64,9 +64,6 @@ class Rig { model.updateMatrixWorld(true); const skinnedMeshes = []; model.traverse(o => { - if (o.isMesh) { - o.frustumCulled = false; - } if (o.isSkinnedMesh) { skinnedMeshes.push(o); } From 35c7d86fc2c1b4915ddc005a48a2f6cafb012032 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 17:30:03 -0400 Subject: [PATCH 396/562] Small data loading cleanup --- vrarmik.html | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/vrarmik.html b/vrarmik.html index b65fbe8..d2c7537 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -540,11 +540,7 @@

Multiplayer

const filename = _pathname2Filename(pathname); const ext = _filename2Ext(filename); const blob = await new Promise((accept, reject) => { - entry.getData(new zip.BlobWriter('application/octet-stream'), function(blob) { - accept(blob); - }, function(current, total) { - // onprogress callback - }); + entry.getData(new zip.BlobWriter('application/octet-stream'), accept, function onprogress(current, total) {}); }); const url = URL.createObjectURL(blob); filesystem.push({ From bffc312dcbde14debfebe63b381c1379a056c1fa Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 20:57:44 -0400 Subject: [PATCH 397/562] Compute flip z from left arm instead of virual eye direction --- vrarmik/Rig.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index ca6a5da..0b97ecb 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -363,7 +363,8 @@ class Rig { } }; const eyeDirection = _getEyePosition().sub(Head.getWorldPosition(new Vector3())); - let flipZ = eyeDirection.z < 0; + const leftArmDirection = Left_wrist.getWorldPosition(new Vector3()).sub(Head.getWorldPosition(new Vector3())); + const flipZ = leftArmDirection.x < 0;//eyeDirection.z < 0; const armatureDirection = new THREE.Vector3(0, 1, 0).applyQuaternion(armature.quaternion); const flipY = armatureDirection.z < -0.5; const legDirection = new Vector3(0, 0, -1).applyQuaternion(Left_leg.getWorldQuaternion(new Quaternion()).premultiply(armature.quaternion.clone().inverse())); From 21fb674b5154be07cb98a25f9231c38b5baada3d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 20:58:31 -0400 Subject: [PATCH 398/562] Small flip z cleanup --- vrarmik/Rig.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index 0b97ecb..e406e78 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -362,7 +362,7 @@ class Rig { return Head.getWorldPosition(new Vector3()).add(neckToHeadDiff); } }; - const eyeDirection = _getEyePosition().sub(Head.getWorldPosition(new Vector3())); + // const eyeDirection = _getEyePosition().sub(Head.getWorldPosition(new Vector3())); const leftArmDirection = Left_wrist.getWorldPosition(new Vector3()).sub(Head.getWorldPosition(new Vector3())); const flipZ = leftArmDirection.x < 0;//eyeDirection.z < 0; const armatureDirection = new THREE.Vector3(0, 1, 0).applyQuaternion(armature.quaternion); @@ -371,7 +371,7 @@ class Rig { const flipLeg = legDirection.y < 0.5; const scaleFactor = Head.getWorldPosition(new Vector3()) .distanceTo(Left_ankle.getWorldPosition(new Vector3())) / Math.abs(armature.scale.y) > 100 ? 100 : 1; - console.log('flip', flipZ, flipY, scaleFactor, eyeDirection.toArray().join(','), armatureDirection.toArray().join(',')); + console.log('flip', flipZ, flipY, scaleFactor); this.flipZ = flipZ; this.flipY = flipY; this.flipLeg = flipLeg; From 4db06bff36c3712fb879c72b128a92344bd39dc8 Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 21:00:37 -0400 Subject: [PATCH 399/562] Bugfix arms prerotations in flip z case --- vrarmik/Rig.js | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/vrarmik/Rig.js b/vrarmik/Rig.js index e406e78..2fbcadd 100644 --- a/vrarmik/Rig.js +++ b/vrarmik/Rig.js @@ -473,42 +473,48 @@ class Rig { }); } - const qr = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * -Math.PI/2) + const qrArm = flipZ ? Left_arm : Right_arm; + const qrElbow = flipZ ? Left_elbow : Right_elbow; + const qrWrist = flipZ ? Left_wrist : Right_wrist; + const qr = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), - Right_elbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) - .sub(Right_arm.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) + qrElbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) + .sub(qrArm.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) .applyQuaternion(armatureQuaternion), new Vector3(0, 1, 0), )) ); - const qr2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * -Math.PI/2) + const qr2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), - Right_wrist.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) - .sub(Right_elbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) + qrWrist.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) + .sub(qrElbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) .applyQuaternion(armatureQuaternion), new Vector3(0, 1, 0), )) ); - const ql = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * Math.PI/2) + const qlArm = flipZ ? Right_arm : Left_arm; + const qlElbow = flipZ ? Right_elbow : Left_elbow; + const qlWrist = flipZ ? Right_wrist : Left_wrist; + const ql = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), - Left_elbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) - .sub(Left_arm.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) + qlElbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) + .sub(qlArm.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) .applyQuaternion(armatureQuaternion), new Vector3(0, 1, 0), )) ); - const ql2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), (flipZ ? -1 : 1) * Math.PI/2) + const ql2 = new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI/2) .premultiply( new Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt( new Vector3(0, 0, 0), - Left_wrist.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) - .sub(Left_elbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) + qlWrist.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse) + .sub(qlElbow.getWorldPosition(new Vector3()).applyMatrix4(armatureMatrixInverse)) .applyQuaternion(armatureQuaternion), new Vector3(0, 1, 0), )) From 3bd985844b6c012e3b9a993e0e146706ff9c2e4d Mon Sep 17 00:00:00 2001 From: Avaer Kazmer Date: Wed, 30 Oct 2019 21:01:04 -0400 Subject: [PATCH 400/562] Add model6.zip example --- vrarmik.html | 1 + 1 file changed, 1 insertion(+) diff --git a/vrarmik.html b/vrarmik.html index d2c7537..bc24fdf 100644 --- a/vrarmik.html +++ b/vrarmik.html @@ -251,6 +251,7 @@

Examples

model3.unitypackage
model4.zip
model5.fbx
+ model6.zip