@ifiwas/standard-view 2.0.0

package/lib/views/SetBackground.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+declare function SetBackground({ backgroundColor, backgroundTextureURL, backgroundEquirectangularTextureURL, backgroundEquirectangularRGBEURL, }: {
+    backgroundColor: any;
+    backgroundTextureURL: any;
+    backgroundEquirectangularTextureURL: any;
+    backgroundEquirectangularRGBEURL: any;
+}): null;
+declare const SetBackgroundMemo: React.MemoExoticComponent<typeof SetBackground>;
+export default SetBackgroundMemo;

package/lib/views/SetBackground.js

@@ -0,0 +1,90 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _three = _interopRequireWildcard(require("three"));
+var THREE = _three;
+var _RGBELoader = require("three/examples/jsm/loaders/RGBELoader");
+var _utils = require("../utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+// SetBackground.tsx
+
+var useEffect = React.useEffect,
+  memo = React.memo;
+function SetBackground(_ref) {
+  var backgroundColor = _ref.backgroundColor,
+    backgroundTextureURL = _ref.backgroundTextureURL,
+    backgroundEquirectangularTextureURL = _ref.backgroundEquirectangularTextureURL,
+    backgroundEquirectangularRGBEURL = _ref.backgroundEquirectangularRGBEURL;
+  var _useViewContext = (0, _utils.useViewContext)(),
+    gl = _useViewContext.gl,
+    scene = _useViewContext.scene,
+    setViewContext = _useViewContext.setViewContext;
+  useEffect(function updateBackground() {
+    var pmremGenerator = new _three.PMREMGenerator(gl);
+    pmremGenerator.compileEquirectangularShader();
+    if (backgroundEquirectangularRGBEURL) {
+      // HDR
+      // RGBE Equirectangular Skybox
+      var path = backgroundEquirectangularRGBEURL;
+      new _RGBELoader.RGBELoader().setDataType(THREE.FloatType).load(path, function (texture) {
+        // Mark as equirectangular
+        texture.mapping = THREE.EquirectangularReflectionMapping;
+        // For HDR normally keep colorSpace as Linear
+        texture.colorSpace = THREE.LinearSRGBColorSpace;
+        scene.background = texture;
+
+        // Using Prefiltered Mipmapped Radiance Environment Map for much smoother envmaps
+        var envMap = pmremGenerator.fromEquirectangular(texture).texture;
+        scene.environment = envMap;
+        setViewContext({
+          envMap: envMap
+        });
+        texture.dispose();
+        pmremGenerator.dispose();
+      });
+    } else if (backgroundEquirectangularTextureURL) {
+      // LDR
+      // Equirectangular Skybox
+      var _path = backgroundEquirectangularTextureURL;
+      new THREE.TextureLoader().load(_path, function (texture) {
+        texture.mapping = THREE.EquirectangularReflectionMapping;
+        texture.colorSpace = THREE.SRGBColorSpace;
+        scene.background = texture;
+        var envMap = pmremGenerator.fromEquirectangular(texture).texture;
+        scene.environment = envMap;
+        setViewContext({
+          envMap: envMap
+        });
+        texture.dispose();
+        pmremGenerator.dispose();
+      });
+    } else if (backgroundTextureURL) {
+      // 2D Background
+      // Background Image
+      var _path2 = backgroundTextureURL;
+      new THREE.TextureLoader().load(_path2, function (texture) {
+        texture.colorSpace = THREE.SRGBColorSpace;
+        scene.background = texture;
+      });
+    } else if (backgroundColor != null) {
+      // Solid Color
+      // Background Color
+      gl.setClearColor(backgroundColor);
+      scene.background = null;
+    }
+  },
+  // setViewContext causes useState to update setViewContexValue
+  // in ViewContextProvider this triggers an update in useViewContext,
+  // hence a endless update cycle will occur if updateBackground depended on setViewContext
+  /* eslint-disable-next-line react-hooks/exhaustive-deps */
+  [gl, scene, backgroundEquirectangularRGBEURL, backgroundEquirectangularTextureURL, backgroundTextureURL, backgroundColor]);
+  return null;
+}
+var SetBackgroundMemo = memo(SetBackground);
+SetBackgroundMemo.displayName = 'SetBackground';
+var _default = exports["default"] = SetBackgroundMemo;

package/lib/views/SetControls.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+declare function SetControls({ controlsType, cameraExtrinsics, polarAngle, azimuthAngle, controlsProps, }: {
+    controlsType: any;
+    cameraExtrinsics: any;
+    polarAngle: any;
+    azimuthAngle: any;
+    controlsProps: any;
+}): null;
+declare const SetControlsMemo: React.MemoExoticComponent<typeof SetControls>;
+export default SetControlsMemo;
+/**
+ * UpdateControls
+ *
+ * Isolates the useFrame hook to avoid larger components, namely
+ * SetControls, from re-rendering up to 3 times--this is a bug
+ * from @react-three/fiber.
+ * Any @react-three/fiber hook call incurs additional renders.
+ */
+export declare const UpdateControls: React.NamedExoticComponent<object>;

package/lib/views/SetControls.js

@@ -0,0 +1,173 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.UpdateControls = void 0;
+var React = _interopRequireWildcard(require("react"));
+var THREE = _interopRequireWildcard(require("three"));
+var _TrackballControls = require("three/examples/jsm/controls/TrackballControls");
+var _OrbitControls = require("three/examples/jsm/controls/OrbitControls");
+var _MapControls = require("three/examples/jsm/controls/MapControls");
+var _hooks = require("../utils/hooks");
+var _constants = require("../utils/constants");
+var _math = require("../utils/math");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; } // SetControls.tsx
+var useEffect = React.useEffect,
+  useState = React.useState,
+  useMemo = React.useMemo,
+  memo = React.memo;
+
+// Helper function for deep comparison
+var isEqual = function isEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+};
+function SetControls(_ref) {
+  var controlsType = _ref.controlsType,
+    cameraExtrinsics = _ref.cameraExtrinsics,
+    polarAngle = _ref.polarAngle,
+    azimuthAngle = _ref.azimuthAngle,
+    controlsProps = _ref.controlsProps;
+  var _useViewContext = (0, _hooks.useViewContext)(),
+    camera = _useViewContext.camera,
+    gl = _useViewContext.gl;
+
+  // Set CameraControls
+  var CameraControls = useMemo(function updateCameraControls() {
+    switch (controlsType) {
+      case _constants.CONTROLS_TYPES.TRACKBALL_CONTROLS:
+        return _TrackballControls.TrackballControls;
+      case _constants.CONTROLS_TYPES.ORBIT_CONTROLS:
+        return _OrbitControls.OrbitControls;
+      case _constants.CONTROLS_TYPES.MAP_CONTROLS:
+        return _MapControls.MapControls;
+      default:
+        return null;
+    }
+  }, [controlsType]);
+  var _useState = useState(controlsProps),
+    _useState2 = _slicedToArray(_useState, 2),
+    _controlsProps = _useState2[0],
+    setControlsProps = _useState2[1];
+  useEffect(function updateControlsProps() {
+    // Update Controls Props
+    if (!isEqual(_controlsProps, controlsProps)) {
+      setControlsProps(controlsProps);
+    }
+  }, [controlsProps, _controlsProps]);
+  var _useState3 = useState(cameraExtrinsics),
+    _useState4 = _slicedToArray(_useState3, 2),
+    _cameraExtrinsics = _useState4[0],
+    setCameraExtrinsics = _useState4[1];
+  useEffect(function updateCameraExtrinsics() {
+    // Update Camera Extrinsics
+    if (!isEqual(_cameraExtrinsics, cameraExtrinsics)) {
+      setCameraExtrinsics(cameraExtrinsics);
+    }
+  }, [cameraExtrinsics, _cameraExtrinsics]);
+  useEffect(function updateCameraControls() {
+    var _camera$position;
+    // Clear Camera Controls
+    if (camera.controls != null) {
+      camera.controls.dispose();
+      camera.controls = null;
+    }
+
+    // Camera Extrinsics
+    var position = _cameraExtrinsics.position,
+      up = _cameraExtrinsics.up,
+      target = _cameraExtrinsics.target,
+      rotation = _cameraExtrinsics.rotation,
+      roll = _cameraExtrinsics.roll;
+    (_camera$position = camera.position).set.apply(_camera$position, _toConsumableArray(position));
+    camera.up = _construct(THREE.Vector3, _toConsumableArray(up)).normalize();
+    camera.target = _construct(THREE.Vector3, _toConsumableArray(target));
+    camera.lookAt(camera.target);
+    if (rotation) {
+      var _camera$rotation;
+      // Default rotation is camera pointing in z-axis with up as y-axis.
+      (_camera$rotation = camera.rotation).set.apply(_camera$rotation, _toConsumableArray(rotation));
+    }
+
+    // Apply Camera Roll
+    camera.roll = roll;
+    var look = target.map(function (val, i) {
+      return val - position[i];
+    });
+    var lookVec = _construct(THREE.Vector3, _toConsumableArray(look)).normalize();
+    var rollQ = new THREE.Quaternion().setFromAxisAngle(lookVec, camera.roll);
+    camera.quaternion.premultiply(rollQ);
+
+    // Prevent gimble lock from parallel look and up
+    if (1 - Math.abs(camera.up.clone().dot(lookVec)) < _math.EPS) {
+      // Offset toward DEFAULT_UP or DEFAULT_NORMAL
+      var offset = 1 - Math.abs(_constants.DEFAULT_UP_VEC3.clone().dot(camera.up)) < _math.EPS ? _constants.DEFAULT_NORMAL_VEC3.clone() : _constants.DEFAULT_UP_VEC3.clone();
+      offset.multiplyScalar(_math.EPS);
+      camera.up.add(offset).normalize();
+      console.warn("[View3D.camera] up and look (target - position) directions are parallel. up has been slightly offset to prevent unexpected camera controls behavior.");
+    }
+    camera.up.applyQuaternion(rollQ);
+
+    // Initialize Camera Controls
+    if (CameraControls != null) {
+      camera.controls = new CameraControls(
+      // polarAngle,
+      // azimuthAngle,
+      camera, gl.domElement);
+      camera.controls.enabled = true;
+    }
+    camera.updateProjectionMatrix();
+  }, [CameraControls, camera, _cameraExtrinsics, polarAngle, azimuthAngle, gl.domElement]);
+  useEffect(function updateCameraControlsProps() {
+    // Update Camera Controls
+    if (CameraControls != null) {
+      if (_controlsProps) {
+        Object.entries(_controlsProps).map(function (_ref2) {
+          var _ref3 = _slicedToArray(_ref2, 2),
+            param = _ref3[0],
+            value = _ref3[1];
+          camera.controls[param] = value;
+          return null;
+        });
+      }
+      camera.controls.update();
+    }
+  }, [CameraControls, camera, _controlsProps]);
+  return null;
+}
+var SetControlsMemo = memo(SetControls);
+SetControlsMemo.displayName = 'SetControls';
+var _default = exports["default"] = SetControlsMemo;
+/**
+ * UpdateControls
+ *
+ * Isolates the useFrame hook to avoid larger components, namely
+ * SetControls, from re-rendering up to 3 times--this is a bug
+ * from @react-three/fiber.
+ * Any @react-three/fiber hook call incurs additional renders.
+ */
+var UpdateControls = exports.UpdateControls = memo(function UpdateControls() {
+  var _useViewContext2 = (0, _hooks.useViewContext)(),
+    camera = _useViewContext2.camera;
+  (0, _hooks.useFrame)(function updateControls() {
+    if (camera.controls != null) {
+      camera.controls.update();
+    }
+  });
+  return null;
+});
+UpdateControls.displayName = 'UpdateControls';

package/lib/views/SetRenderer.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import * as THREE from 'three';
+interface GLProps {
+    autoClear?: boolean;
+    autoClearColor?: boolean;
+    autoClearDepth?: boolean;
+    autoClearStencil?: boolean;
+    clippingPlanes?: Array<THREE.Plane>;
+    domElement?: React.DOMElement<any, any>;
+    gammaFactor?: number;
+    outputEncoding?: number;
+    localClippingEnabled?: boolean;
+    maxMorphTargets?: number;
+    maxMorphNormals?: number;
+    physicallyCorrectLights?: boolean;
+    sortObjects?: boolean;
+    toneMapping?: number;
+    toneMappingExposure?: number;
+    toneMappingWhitePoint?: number;
+    antialias?: boolean;
+    preserveDrawingBuffer?: boolean;
+}
+declare function SetRenderer(glProps: GLProps): null;
+declare const SetRendererMemo: React.MemoExoticComponent<typeof SetRenderer>;
+export default SetRendererMemo;

package/lib/views/SetRenderer.js

@@ -0,0 +1,66 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _hooks = require("../utils/hooks");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; } // SetRenderer.tsx
+var useEffect = React.useEffect,
+  memo = React.memo;
+function SetRenderer(glProps) {
+  var _useViewContext = (0, _hooks.useViewContext)(),
+    gl = _useViewContext.gl;
+  useEffect(function initRenderer() {
+    gl.autoClear = false;
+    gl.autoClearColor = false;
+    gl.autoClearDepth = false;
+    gl.autoClearStencil = false;
+    Object.entries(glProps).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      gl[key] = value;
+      return null;
+    });
+  }, [glProps, gl]);
+
+  // Render Loop Head
+  (0, _hooks.useFrame)(/* eslint-disable no-shadow */
+  function renderLoopHead(_ref3) {
+    var gl = _ref3.gl,
+      scene = _ref3.scene;
+    /* eslint-enable no-shadow */
+    /* eslint-disable no-param-reassign */
+    scene.overrideMaterial = null;
+    // @ts-ignore:TS2339 cancelTailRender does not exist
+    scene.cancelTailRender = false;
+    gl.clear();
+    gl.clippingPlanes = [];
+    /* eslint-enable no-param-reassign */
+  }, 1, true);
+
+  // Render Loop Tail
+  (0, _hooks.useFrame)(/* eslint-disable-next-line no-shadow */
+  function renderLoopTall(_ref4) {
+    var gl = _ref4.gl,
+      scene = _ref4.scene,
+      camera = _ref4.camera;
+    // @ts-ignore:TS2339 cancelTailRender does not exist
+    if (!scene.cancelTailRender) {
+      gl.render(scene, camera);
+    }
+  }, 1000, true);
+  return null;
+}
+var SetRendererMemo = memo(SetRenderer);
+SetRendererMemo.displayName = 'SetRenderer';
+var _default = exports["default"] = SetRendererMemo;

package/lib/views/SetShadows.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare function SetShadows({ shadowMapEnabled, shadowType }: {
+    shadowMapEnabled: any;
+    shadowType: any;
+}): null;
+declare const SetShadowsMemo: React.MemoExoticComponent<typeof SetShadows>;
+export default SetShadowsMemo;

package/lib/views/SetShadows.js

@@ -0,0 +1,48 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var React = _interopRequireWildcard(require("react"));
+var THREE = _interopRequireWildcard(require("three"));
+var _RectAreaLightUniformsLib = require("three/examples/jsm/lights/RectAreaLightUniformsLib");
+var _utils = require("../utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+// SetShadows.tsx
+
+var useEffect = React.useEffect,
+  memo = React.memo;
+function SetShadows(_ref) {
+  var shadowMapEnabled = _ref.shadowMapEnabled,
+    shadowType = _ref.shadowType;
+  var _useViewContext = (0, _utils.useViewContext)(),
+    gl = _useViewContext.gl;
+  useEffect(function updateShadowMap() {
+    gl.shadowMap.enabled = shadowMapEnabled;
+    if (!shadowMapEnabled) {
+      return;
+    }
+    switch (shadowType) {
+      case "basic":
+        gl.shadowMap.type = THREE.BasicShadowMap;
+        break;
+      case "pcf":
+        gl.shadowMap.type = THREE.PCFShadowMap;
+        break;
+      case "pcfsoft":
+        gl.shadowMap.type = THREE.PCFSoftShadowMap;
+        break;
+      default:
+        gl.shadowMap.type = THREE.PCFSoftShadowMap;
+    }
+  }, [shadowMapEnabled, shadowType, gl]);
+  useEffect(function initRectAreaLightUniforms() {
+    _RectAreaLightUniformsLib.RectAreaLightUniformsLib.init();
+  }, []);
+  return null;
+}
+var SetShadowsMemo = memo(SetShadows);
+SetShadowsMemo.displayName = "SetShadows";
+var _default = exports["default"] = SetShadowsMemo;

package/lib/views/View3D.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+interface View3DProps {
+    backgroundColor?: string;
+    backgroundTextureURL?: string;
+    backgroundEquirectangularTextureURL?: string;
+    backgroundEquirectangularRGBEURL?: string;
+    trackballControls?: boolean;
+    orbitControls?: boolean;
+    mapControls?: boolean;
+    shadowMapEnabled?: boolean;
+    shadowType?: string;
+    orthographic?: boolean;
+    camera?: any;
+    controls?: any;
+    gl?: any;
+    contexts?: React.Context<any> | Array<React.Context<any>>;
+    style?: Record<string, any>;
+    children: any;
+}
+declare const View3DMemo: React.NamedExoticComponent<View3DProps>;
+export default View3DMemo;