reality-three
Version:
Simple light-weight game engine using three.js, three-mesh-ui and rapier
141 lines (138 loc) • 8.44 kB
JavaScript
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
import EventEmitter from "events";
// TODO possibly use promise chaining to serialize calls to isSessionSupported + requestSession
var VRMode = /*#__PURE__*/function (_EventEmitter) {
_inherits(VRMode, _EventEmitter);
var _super = _createSuper(VRMode);
function VRMode() {
var _this;
_classCallCheck(this, VRMode);
_this = _super.call(this);
_defineProperty(_assertThisInitialized(_this), "_onDeviceChange", function () {
console.log('VRMode: navigator.xr devicechange event');
_this._checkForImmersizeVRSupport();
});
_defineProperty(_assertThisInitialized(_this), "_onSessionStarted", function (session) {
console.log('VRMode: session started');
session.addEventListener('end', _this._onSessionEnded);
_this._session = session;
_this.emit('SESSION_STARTED', session);
_this.emit('CHANGE');
});
_defineProperty(_assertThisInitialized(_this), "_onSessionEnded", function () {
console.log('VRMode: session ended');
_this._session.removeEventListener('end', _this._onSessionEnded);
_this._session = null;
_this.emit('SESSION_ENDED');
_this.emit('CHANGE');
});
_this._session = null;
_this.webXRSupported = "xr" in window.navigator;
_this.immersiveVRSupported = false;
_this.immersiveVRChecked = false;
if (_this.webXRSupported) {
window.navigator.xr.addEventListener('devicechange', _this._onDeviceChange);
_this._checkForImmersizeVRSupport();
}
return _this;
}
_createClass(VRMode, [{
key: "isWebXRSupported",
value: function isWebXRSupported() {
return this.webXRSupported;
}
}, {
key: "isImmersiveVRSupported",
value: function isImmersiveVRSupported() {
return this.immersiveVRSupported;
}
}, {
key: "hasCheckedImmersiveVRSupport",
value: function hasCheckedImmersiveVRSupport() {
return this.immersiveVRChecked;
}
}, {
key: "_setImmersiveVRSupported",
value: function _setImmersiveVRSupported(value) {
if (this.immersiveVRSupported !== value || !this.immersiveVRChecked) {
this.immersiveVRSupported = value;
this.immersiveVRChecked = true;
this.emit('CHANGE');
}
}
}, {
key: "_checkForImmersizeVRSupport",
value: function _checkForImmersizeVRSupport() {
var _this2 = this;
if (!this.webXRSupported) {
this._setImmersiveVRSupported(false);
return;
}
var onCheckComplete = function onCheckComplete(supported) {
console.log('VRMode: immersive-vr supported: ', supported);
_this2._setImmersiveVRSupported(supported);
};
var onCheckFailed = function onCheckFailed(error) {
console.error('VRMode: isSessionSupported check failed! error: ', error);
throw error;
};
console.log('VRMode: checking navigator.xr.isSessionSupported("immersive-vr")...');
window.navigator.xr.isSessionSupported('immersive-vr').then(onCheckComplete, onCheckFailed);
}
}, {
key: "enter",
value: function enter() {
if (this._session) {
console.warn('VRMode: enter(): session already active');
return;
}
// WebXR's requestReferenceSpace only works if the corresponding feature
// was requested at session creation time. For simplicity, just ask for
// the interesting ones as optional features, but be aware that the
// requestReferenceSpace call will fail if it turns out to be unavailable.
// ('local' is always available for immersive sessions and doesn't need to
// be requested separately.)
var sessionInit = {
optionalFeatures: ['local-floor', 'bounded-floor', 'hand-tracking'
//'layers'
]
};
var onRequestSessionFailed = function onRequestSessionFailed(e) {
console.error('VRMode: request session failed');
console.log(e);
};
console.log('VRMode: requesting immersive-vr session...');
window.navigator.xr.requestSession('immersive-vr', sessionInit).then(this._onSessionStarted, onRequestSessionFailed);
}
}, {
key: "exit",
value: function exit() {
if (this._session) {
console.log('VRMode: ending session');
this._session.end();
} else {
console.warn('VRMode: exit(): no active session');
}
}
}, {
key: "getSession",
value: function getSession() {
return this._session;
}
}]);
return VRMode;
}(EventEmitter);
export default VRMode;