mage-engine 3.16.6 → 3.16.7

package/dist/mage.js

@@ -54628,7 +54628,7 @@ var EFFECTS = {
   HUE_SATURATION: 'HUESATURATIONEFFECT',
   BLOOM: 'BLOOM',
   DEPTH_OF_FIELD: 'DOF',
-  // SELECTIVE_OUTLINE: 'SELECTIVEOUTLINE',
+  SELECTIVE_OUTLINE: 'SELECTIVEOUTLINE',
   OUTLINE: 'OUTLINE',
   GLITCH: 'GLITCH',
   PIXEL: 'PIXEL'
@@ -56231,7 +56231,7 @@ function applyMiddleware() {
 
 var thunk = createThunkMiddleware();
 thunk.withExtraArgument = createThunkMiddleware;var name = "mage-engine";
-var version = "3.16.6";
+var version = "3.16.7";
 var description = "A WebGL Javascript Game Engine, built on top of THREE.js and many other libraries.";
 var main = "dist/mage.js";
 var author = {
@@ -57602,6 +57602,9 @@ var getProportion = function getProportion(max1, b, max2) {
 var clamp = function clamp(value, min, max) {
   return value < min ? min : value > max ? max : value;
 };
+var isWithin = function isWithin(value, min, max) {
+  return value >= min && value < max;
+};
 var randomIntFromInterval = function randomIntFromInterval(min, max) {
   // min and max included 
   return Math.floor(Math.random() * (max - min + 1) + min);
@@ -57715,7 +57718,7 @@ var smoothDampAngle = function smoothDampAngle(current, target, currentVelocity,
   var dt = arguments.length > 5 ? arguments[5] : undefined;
   target = current + deltaAngle(current, target);
   return smoothDamp(current, target, currentVelocity, smoothTime, maxSpeed, dt);
-};var math=/*#__PURE__*/Object.freeze({__proto__:null,PI: PI,PI_2: PI_2,pickRandom: pickRandom,degToRad: degToRad,getProportion: getProportion,clamp: clamp,randomIntFromInterval: randomIntFromInterval,getDistance: getDistance,findPointBetweenAtDistance: findPointBetweenAtDistance,lerpVectors: lerpVectors,lerp: lerp,scaleVector: scaleVector,getSphereVolume: getSphereVolume,repeat: repeat,deltaAngle: deltaAngle,smoothDamp: smoothDamp,smoothDampAngle: smoothDampAngle});var LIBRARY_NAME = 'ammo.js';
+};var math=/*#__PURE__*/Object.freeze({__proto__:null,PI: PI,PI_2: PI_2,pickRandom: pickRandom,degToRad: degToRad,getProportion: getProportion,clamp: clamp,isWithin: isWithin,randomIntFromInterval: randomIntFromInterval,getDistance: getDistance,findPointBetweenAtDistance: findPointBetweenAtDistance,lerpVectors: lerpVectors,lerp: lerp,scaleVector: scaleVector,getSphereVolume: getSphereVolume,repeat: repeat,deltaAngle: deltaAngle,smoothDamp: smoothDamp,smoothDampAngle: smoothDampAngle});var LIBRARY_NAME = 'ammo.js';
 var TYPES = {
   BOX: 'BOX',
   SPHERE: 'SPHERE',
@@ -60450,7 +60453,7 @@ var Entity = /*#__PURE__*/function (_EventDispatcher) {
         var _add = function _add(toAdd) {
           _this2.children.push(toAdd);
 
-          _this2.body.add(toAdd.getBody());
+          _this2.getBody().add(toAdd.getBody());
         };
 
         if (Array.isArray(element)) {
@@ -75330,30 +75333,42 @@ var LightLoader$1 = new LightLoader();var Pass = /*#__PURE__*/function () {
   return Pass;
 }(); // Helper for passes that need to fill the viewport with a single quad.
 
-Pass.FullScreenQuad = function () {
-  var camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
-  var geometry = new PlaneGeometry(2, 2);
+var _camera$1 = new OrthographicCamera(-1, 1, 1, -1, 0, 1); // https://github.com/mrdoob/three.js/pull/21358
 
-  var FullScreenQuad = function FullScreenQuad(material) {
-    this._mesh = new Mesh(geometry, material);
-  };
 
-  Object.defineProperty(FullScreenQuad.prototype, 'material', {
+var _geometry$1 = new BufferGeometry();
+
+_geometry$1.setAttribute('position', new Float32BufferAttribute([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3));
+
+_geometry$1.setAttribute('uv', new Float32BufferAttribute([0, 2, 0, 0, 2, 0], 2));
+
+var FullScreenQuad = /*#__PURE__*/function () {
+  function FullScreenQuad(material) {
+    _classCallCheck(this, FullScreenQuad);
+
+    this._mesh = new Mesh(_geometry$1, material);
+  }
+
+  _createClass(FullScreenQuad, [{
+    key: "dispose",
+    value: function dispose() {
+      this._mesh.geometry.dispose();
+    }
+  }, {
+    key: "render",
+    value: function render(renderer) {
+      renderer.render(this._mesh, _camera$1);
+    }
+  }, {
+    key: "material",
     get: function get() {
       return this._mesh.material;
     },
     set: function set(value) {
       this._mesh.material = value;
     }
-  });
-  Object.assign(FullScreenQuad.prototype, {
-    dispose: function dispose() {
-      this._mesh.geometry.dispose();
-    },
-    render: function render(renderer) {
-      renderer.render(this._mesh, camera);
-    }
-  });
+  }]);
+
   return FullScreenQuad;
 }();var ShaderPass = /*#__PURE__*/function (_Pass) {
   _inherits(ShaderPass, _Pass);
@@ -75381,7 +75396,7 @@ Pass.FullScreenQuad = function () {
       });
     }
 
-    _this.fsQuad = new Pass.FullScreenQuad(_this.material);
+    _this.fsQuad = new FullScreenQuad(_this.material);
     return _this;
   }
 
@@ -75928,7 +75943,7 @@ var BloomPass = /*#__PURE__*/function (_Pass) {
       }
     });
     _this.needsSwap = false;
-    _this.fsQuad = new Pass.FullScreenQuad(null);
+    _this.fsQuad = new FullScreenQuad(null);
     _this.renderToScreen = renderToScreen;
     return _this;
   }
@@ -76057,7 +76072,7 @@ var BokehShader = {
     });
     _this.uniforms = bokehUniforms;
     _this.needsSwap = false;
-    _this.fsQuad = new Pass.FullScreenQuad(_this.materialBokeh);
+    _this.fsQuad = new FullScreenQuad(_this.materialBokeh);
     _this._oldClearColor = new Color();
     _this.renderToScreen = renderToScreen;
     return _this;
@@ -76136,7 +76151,464 @@ var BokehShader = {
   }
 
   return DepthOfField;
-}(BokehPass);/**
+}(BokehPass);var MAX_EDGE_THICKNESS = 4;
+var MAX_EDGE_GLOW = 4;
+var BlurDirectionX = new Vector2(1.0, 0.0);
+var BlurDirectionY = new Vector2(0.0, 1.0);
+
+var replaceDepthToViewZ = function replaceDepthToViewZ(string, camera) {
+  var type = camera.isPerspectiveCamera ? 'perspective' : 'orthographic';
+  return string.replace(/DEPTH_TO_VIEW_Z/g, type + 'DepthToViewZ');
+};
+
+var SelectiveOutline = /*#__PURE__*/function (_Pass) {
+  _inherits(SelectiveOutline, _Pass);
+
+  var _super = _createSuper(SelectiveOutline);
+
+  function SelectiveOutline(_ref) {
+    var _this;
+
+    var _ref$resolution = _ref.resolution,
+        resolution = _ref$resolution === void 0 ? {} : _ref$resolution,
+        selectedObjects = _ref.selectedObjects,
+        _ref$visibleEdgeColor = _ref.visibleEdgeColor,
+        visibleEdgeColor = _ref$visibleEdgeColor === void 0 ? PALETTES.BASE.WHITE : _ref$visibleEdgeColor,
+        _ref$hiddenEdgeColor = _ref.hiddenEdgeColor,
+        hiddenEdgeColor = _ref$hiddenEdgeColor === void 0 ? PALETTES.BASE.BLACK : _ref$hiddenEdgeColor;
+
+    _classCallCheck(this, SelectiveOutline);
+
+    _this = _super.call(this);
+
+    var _config$screen = Config$1.screen(),
+        height = _config$screen.h,
+        width = _config$screen.w;
+
+    var _resolution$x = resolution.x,
+        resolutionX = _resolution$x === void 0 ? width : _resolution$x,
+        _resolution$y = resolution.y,
+        resolutionY = _resolution$y === void 0 ? height : _resolution$y;
+    _this.renderScene = Scene$2.getScene();
+    _this.renderCamera = Scene$2.getCameraBody();
+    _this.selectedObjects = selectedObjects !== undefined ? selectedObjects : [];
+    _this.visibleEdgeColor = visibleEdgeColor;
+    _this.hiddenEdgeColor = hiddenEdgeColor;
+    _this.edgeGlow = 0.0;
+    _this.usePatternTexture = false;
+    _this.edgeThickness = 1.0;
+    _this.edgeStrength = 3.0;
+    _this.downSampleRatio = 2;
+    _this.pulsePeriod = 0;
+    _this._visibilityCache = new Map();
+    _this.resolution = new Vector2(resolutionX, resolutionY);
+    var pars = {
+      minFilter: LinearFilter,
+      magFilter: LinearFilter,
+      format: RGBAFormat
+    };
+    var resx = Math.round(_this.resolutionX / _this.downSampleRatio);
+    var resy = Math.round(_this.resolutionY / _this.downSampleRatio);
+    _this.renderTargetMaskBuffer = new WebGLRenderTarget(_this.resolutionX, _this.resolutionY, pars);
+    _this.renderTargetMaskBuffer.texture.name = 'OutlinePass.mask';
+    _this.renderTargetMaskBuffer.texture.generateMipmaps = false;
+    _this.depthMaterial = new MeshDepthMaterial();
+    _this.depthMaterial.side = DoubleSide;
+    _this.depthMaterial.depthPacking = RGBADepthPacking;
+    _this.depthMaterial.blending = NoBlending;
+    _this.prepareMaskMaterial = _this.getPrepareMaskMaterial();
+    _this.prepareMaskMaterial.side = DoubleSide;
+    _this.prepareMaskMaterial.fragmentShader = replaceDepthToViewZ(_this.prepareMaskMaterial.fragmentShader, _this.renderCamera);
+    _this.renderTargetDepthBuffer = new WebGLRenderTarget(_this.resolutionX, _this.resolutionY, pars);
+    _this.renderTargetDepthBuffer.texture.name = 'OutlinePass.depth';
+    _this.renderTargetDepthBuffer.texture.generateMipmaps = false;
+    _this.renderTargetMaskDownSampleBuffer = new WebGLRenderTarget(resx, resy, pars);
+    _this.renderTargetMaskDownSampleBuffer.texture.name = 'OutlinePass.depthDownSample';
+    _this.renderTargetMaskDownSampleBuffer.texture.generateMipmaps = false;
+    _this.renderTargetBlurBuffer1 = new WebGLRenderTarget(resx, resy, pars);
+    _this.renderTargetBlurBuffer1.texture.name = 'OutlinePass.blur1';
+    _this.renderTargetBlurBuffer1.texture.generateMipmaps = false;
+    _this.renderTargetBlurBuffer2 = new WebGLRenderTarget(Math.round(resx / 2), Math.round(resy / 2), pars);
+    _this.renderTargetBlurBuffer2.texture.name = 'OutlinePass.blur2';
+    _this.renderTargetBlurBuffer2.texture.generateMipmaps = false;
+    _this.edgeDetectionMaterial = _this.getEdgeDetectionMaterial();
+    _this.renderTargetEdgeBuffer1 = new WebGLRenderTarget(resx, resy, pars);
+    _this.renderTargetEdgeBuffer1.texture.name = 'OutlinePass.edge1';
+    _this.renderTargetEdgeBuffer1.texture.generateMipmaps = false;
+    _this.renderTargetEdgeBuffer2 = new WebGLRenderTarget(Math.round(resx / 2), Math.round(resy / 2), pars);
+    _this.renderTargetEdgeBuffer2.texture.name = 'OutlinePass.edge2';
+    _this.renderTargetEdgeBuffer2.texture.generateMipmaps = false;
+    _this.separableBlurMaterial1 = _this.getSeperableBlurMaterial(MAX_EDGE_THICKNESS);
+
+    _this.separableBlurMaterial1.uniforms['texSize'].value.set(resx, resy);
+
+    _this.separableBlurMaterial1.uniforms['kernelRadius'].value = 1;
+    _this.separableBlurMaterial2 = _this.getSeperableBlurMaterial(MAX_EDGE_GLOW);
+
+    _this.separableBlurMaterial2.uniforms['texSize'].value.set(Math.round(resx / 2), Math.round(resy / 2));
+
+    _this.separableBlurMaterial2.uniforms['kernelRadius'].value = MAX_EDGE_GLOW; // Overlay material
+
+    _this.overlayMaterial = _this.getOverlayMaterial(); // copy material
+
+    if (CopyShader === undefined) console.error('THREE.OutlinePass relies on CopyShader');
+    var copyShader = CopyShader;
+    _this.copyUniforms = UniformsUtils.clone(copyShader.uniforms);
+    _this.copyUniforms['opacity'].value = 1.0;
+    _this.materialCopy = new ShaderMaterial({
+      uniforms: _this.copyUniforms,
+      vertexShader: copyShader.vertexShader,
+      fragmentShader: copyShader.fragmentShader,
+      blending: NoBlending,
+      depthTest: false,
+      depthWrite: false,
+      transparent: true
+    });
+    _this.enabled = true;
+    _this.needsSwap = false;
+    _this._oldClearColor = new Color();
+    _this.oldClearAlpha = 1;
+    _this.fsQuad = new FullScreenQuad(null);
+    _this.tempPulseColor1 = new Color();
+    _this.tempPulseColor2 = new Color();
+    _this.textureMatrix = new Matrix4();
+    return _this;
+  }
+
+  _createClass(SelectiveOutline, [{
+    key: "setSelectedObjects",
+    value: function setSelectedObjects() {
+      var selectedObjects = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      this.selectedObjects = selectedObjects.map(function (o) {
+        return o.getBody();
+      });
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.renderTargetMaskBuffer.dispose();
+      this.renderTargetDepthBuffer.dispose();
+      this.renderTargetMaskDownSampleBuffer.dispose();
+      this.renderTargetBlurBuffer1.dispose();
+      this.renderTargetBlurBuffer2.dispose();
+      this.renderTargetEdgeBuffer1.dispose();
+      this.renderTargetEdgeBuffer2.dispose();
+    }
+  }, {
+    key: "setSize",
+    value: function setSize(width, height) {
+      this.renderTargetMaskBuffer.setSize(width, height);
+      this.renderTargetDepthBuffer.setSize(width, height);
+      var resx = Math.round(width / this.downSampleRatio);
+      var resy = Math.round(height / this.downSampleRatio);
+      this.renderTargetMaskDownSampleBuffer.setSize(resx, resy);
+      this.renderTargetBlurBuffer1.setSize(resx, resy);
+      this.renderTargetEdgeBuffer1.setSize(resx, resy);
+      this.separableBlurMaterial1.uniforms['texSize'].value.set(resx, resy);
+      resx = Math.round(resx / 2);
+      resy = Math.round(resy / 2);
+      this.renderTargetBlurBuffer2.setSize(resx, resy);
+      this.renderTargetEdgeBuffer2.setSize(resx, resy);
+      this.separableBlurMaterial2.uniforms['texSize'].value.set(resx, resy);
+    }
+  }, {
+    key: "changeVisibilityOfSelectedObjects",
+    value: function changeVisibilityOfSelectedObjects(bVisible) {
+      var cache = this._visibilityCache;
+
+      function gatherSelectedMeshesCallBack(object) {
+        if (object.isMesh) {
+          if (bVisible === true) {
+            object.visible = cache.get(object);
+          } else {
+            cache.set(object, object.visible);
+            object.visible = bVisible;
+          }
+        }
+      }
+
+      for (var i = 0; i < this.selectedObjects.length; i++) {
+        var selectedObject = this.selectedObjects[i];
+        selectedObject.traverse(gatherSelectedMeshesCallBack);
+      }
+    }
+  }, {
+    key: "changeVisibilityOfNonSelectedObjects",
+    value: function changeVisibilityOfNonSelectedObjects(bVisible) {
+      var cache = this._visibilityCache;
+      var selectedMeshes = [];
+
+      function gatherSelectedMeshesCallBack(object) {
+        if (object.isMesh) selectedMeshes.push(object);
+      }
+
+      for (var i = 0; i < this.selectedObjects.length; i++) {
+        var selectedObject = this.selectedObjects[i];
+        selectedObject.traverse(gatherSelectedMeshesCallBack);
+      }
+
+      function VisibilityChangeCallBack(object) {
+        if (object.isMesh || object.isSprite) {
+          // only meshes and sprites are supported by OutlinePass
+          var bFound = false;
+
+          for (var _i = 0; _i < selectedMeshes.length; _i++) {
+            var selectedObjectId = selectedMeshes[_i].id;
+
+            if (selectedObjectId === object.id) {
+              bFound = true;
+              break;
+            }
+          }
+
+          if (bFound === false) {
+            var visibility = object.visible;
+
+            if (bVisible === false || cache.get(object) === true) {
+              object.visible = bVisible;
+            }
+
+            cache.set(object, visibility);
+          }
+        } else if (object.isPoints || object.isLine) {
+          // the visibilty of points and lines is always set to false in order to
+          // not affect the outline computation
+          if (bVisible === true) {
+            object.visible = cache.get(object); // restore
+          } else {
+            cache.set(object, object.visible);
+            object.visible = bVisible;
+          }
+        }
+      }
+
+      this.renderScene.traverse(VisibilityChangeCallBack);
+    }
+  }, {
+    key: "updateTextureMatrix",
+    value: function updateTextureMatrix() {
+      this.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);
+      this.textureMatrix.multiply(this.renderCamera.projectionMatrix);
+      this.textureMatrix.multiply(this.renderCamera.matrixWorldInverse);
+    }
+  }, {
+    key: "render",
+    value: function render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
+      if (this.selectedObjects.length > 0) {
+        renderer.getClearColor(this._oldClearColor);
+        this.oldClearAlpha = renderer.getClearAlpha();
+        var oldAutoClear = renderer.autoClear;
+        renderer.autoClear = false;
+        if (maskActive) renderer.state.buffers.stencil.setTest(false);
+        renderer.setClearColor(0xffffff, 1); // Make selected objects invisible
+
+        this.changeVisibilityOfSelectedObjects(false);
+        var currentBackground = this.renderScene.background;
+        this.renderScene.background = null; // 1. Draw Non Selected objects in the depth buffer
+
+        this.renderScene.overrideMaterial = this.depthMaterial;
+        renderer.setRenderTarget(this.renderTargetDepthBuffer);
+        renderer.clear();
+        renderer.render(this.renderScene, this.renderCamera); // Make selected objects visible
+
+        this.changeVisibilityOfSelectedObjects(true);
+
+        this._visibilityCache.clear(); // Update Texture Matrix for Depth compare
+
+
+        this.updateTextureMatrix(); // Make non selected objects invisible, and draw only the selected objects, by comparing the depth buffer of non selected objects
+
+        this.changeVisibilityOfNonSelectedObjects(false);
+        this.renderScene.overrideMaterial = this.prepareMaskMaterial;
+        this.prepareMaskMaterial.uniforms['cameraNearFar'].value.set(this.renderCamera.near, this.renderCamera.far);
+        this.prepareMaskMaterial.uniforms['depthTexture'].value = this.renderTargetDepthBuffer.texture;
+        this.prepareMaskMaterial.uniforms['textureMatrix'].value = this.textureMatrix;
+        renderer.setRenderTarget(this.renderTargetMaskBuffer);
+        renderer.clear();
+        renderer.render(this.renderScene, this.renderCamera);
+        this.renderScene.overrideMaterial = null;
+        this.changeVisibilityOfNonSelectedObjects(true);
+
+        this._visibilityCache.clear();
+
+        this.renderScene.background = currentBackground; // 2. Downsample to Half resolution
+
+        this.fsQuad.material = this.materialCopy;
+        this.copyUniforms['tDiffuse'].value = this.renderTargetMaskBuffer.texture;
+        renderer.setRenderTarget(this.renderTargetMaskDownSampleBuffer);
+        renderer.clear();
+        this.fsQuad.render(renderer);
+        this.tempPulseColor1.copy(this.visibleEdgeColor);
+        this.tempPulseColor2.copy(this.hiddenEdgeColor);
+
+        if (this.pulsePeriod > 0) {
+          var scalar = (1 + 0.25) / 2 + Math.cos(performance.now() * 0.01 / this.pulsePeriod) * (1.0 - 0.25) / 2;
+          this.tempPulseColor1.multiplyScalar(scalar);
+          this.tempPulseColor2.multiplyScalar(scalar);
+        } // 3. Apply Edge Detection Pass
+
+
+        this.fsQuad.material = this.edgeDetectionMaterial;
+        this.edgeDetectionMaterial.uniforms['maskTexture'].value = this.renderTargetMaskDownSampleBuffer.texture;
+        this.edgeDetectionMaterial.uniforms['texSize'].value.set(this.renderTargetMaskDownSampleBuffer.width, this.renderTargetMaskDownSampleBuffer.height);
+        this.edgeDetectionMaterial.uniforms['visibleEdgeColor'].value = this.tempPulseColor1;
+        this.edgeDetectionMaterial.uniforms['hiddenEdgeColor'].value = this.tempPulseColor2;
+        renderer.setRenderTarget(this.renderTargetEdgeBuffer1);
+        renderer.clear();
+        this.fsQuad.render(renderer); // 4. Apply Blur on Half res
+
+        this.fsQuad.material = this.separableBlurMaterial1;
+        this.separableBlurMaterial1.uniforms['colorTexture'].value = this.renderTargetEdgeBuffer1.texture;
+        this.separableBlurMaterial1.uniforms['direction'].value = BlurDirectionX;
+        this.separableBlurMaterial1.uniforms['kernelRadius'].value = this.edgeThickness;
+        renderer.setRenderTarget(this.renderTargetBlurBuffer1);
+        renderer.clear();
+        this.fsQuad.render(renderer);
+        this.separableBlurMaterial1.uniforms['colorTexture'].value = this.renderTargetBlurBuffer1.texture;
+        this.separableBlurMaterial1.uniforms['direction'].value = BlurDirectionY;
+        renderer.setRenderTarget(this.renderTargetEdgeBuffer1);
+        renderer.clear();
+        this.fsQuad.render(renderer); // Apply Blur on quarter res
+
+        this.fsQuad.material = this.separableBlurMaterial2;
+        this.separableBlurMaterial2.uniforms['colorTexture'].value = this.renderTargetEdgeBuffer1.texture;
+        this.separableBlurMaterial2.uniforms['direction'].value = BlurDirectionX;
+        renderer.setRenderTarget(this.renderTargetBlurBuffer2);
+        renderer.clear();
+        this.fsQuad.render(renderer);
+        this.separableBlurMaterial2.uniforms['colorTexture'].value = this.renderTargetBlurBuffer2.texture;
+        this.separableBlurMaterial2.uniforms['direction'].value = BlurDirectionY;
+        renderer.setRenderTarget(this.renderTargetEdgeBuffer2);
+        renderer.clear();
+        this.fsQuad.render(renderer); // Blend it additively over the input texture
+
+        this.fsQuad.material = this.overlayMaterial;
+        this.overlayMaterial.uniforms['maskTexture'].value = this.renderTargetMaskBuffer.texture;
+        this.overlayMaterial.uniforms['edgeTexture1'].value = this.renderTargetEdgeBuffer1.texture;
+        this.overlayMaterial.uniforms['edgeTexture2'].value = this.renderTargetEdgeBuffer2.texture;
+        this.overlayMaterial.uniforms['patternTexture'].value = this.patternTexture;
+        this.overlayMaterial.uniforms['edgeStrength'].value = this.edgeStrength;
+        this.overlayMaterial.uniforms['edgeGlow'].value = this.edgeGlow;
+        this.overlayMaterial.uniforms['usePatternTexture'].value = this.usePatternTexture;
+        if (maskActive) renderer.state.buffers.stencil.setTest(true);
+        renderer.setRenderTarget(readBuffer);
+        this.fsQuad.render(renderer);
+        renderer.setClearColor(this._oldClearColor, this.oldClearAlpha);
+        renderer.autoClear = oldAutoClear;
+      }
+
+      if (this.renderToScreen) {
+        this.fsQuad.material = this.materialCopy;
+        this.copyUniforms['tDiffuse'].value = readBuffer.texture;
+        renderer.setRenderTarget(null);
+        this.fsQuad.render(renderer);
+      }
+    }
+  }, {
+    key: "getPrepareMaskMaterial",
+    value: function getPrepareMaskMaterial() {
+      return new ShaderMaterial({
+        uniforms: {
+          'depthTexture': {
+            value: null
+          },
+          'cameraNearFar': {
+            value: new Vector2(0.5, 0.5)
+          },
+          'textureMatrix': {
+            value: null
+          }
+        },
+        vertexShader: "#include <morphtarget_pars_vertex>\n                #include <skinning_pars_vertex>\n\n                varying vec4 projTexCoord;\n                varying vec4 vPosition;\n                uniform mat4 textureMatrix;\n\n                void main() {\n\n                    #include <skinbase_vertex>\n                    #include <begin_vertex>\n                    #include <morphtarget_vertex>\n                    #include <skinning_vertex>\n                    #include <project_vertex>\n\n                    vPosition = mvPosition;\n                    vec4 worldPosition = modelMatrix * vec4(transformed, 1.0);\n                    projTexCoord = textureMatrix * worldPosition;\n\n                }",
+        fragmentShader: "#include <packing>\n                varying vec4 vPosition;\n                varying vec4 projTexCoord;\n                uniform sampler2D depthTexture;\n                uniform vec2 cameraNearFar;\n\n                void main() {\n\n                    float depth = unpackRGBAToDepth(texture2DProj(depthTexture, projTexCoord));\n                    float viewZ = - DEPTH_TO_VIEW_Z(depth, cameraNearFar.x, cameraNearFar.y);\n                    float depthTest = (-vPosition.z > viewZ) ? 1.0 : 0.0;\n                    gl_FragColor = vec4(0.0, depthTest, 1.0, 1.0);\n\n                }"
+      });
+    }
+  }, {
+    key: "getEdgeDetectionMaterial",
+    value: function getEdgeDetectionMaterial() {
+      return new ShaderMaterial({
+        uniforms: {
+          'maskTexture': {
+            value: null
+          },
+          'texSize': {
+            value: new Vector2(0.5, 0.5)
+          },
+          'visibleEdgeColor': {
+            value: new Vector3$1(1.0, 1.0, 1.0)
+          },
+          'hiddenEdgeColor': {
+            value: new Vector3$1(1.0, 1.0, 1.0)
+          }
+        },
+        vertexShader: "varying vec2 vUv;\n\n                void main() {\n                    vUv = uv;\n                    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n                }",
+        fragmentShader: "varying vec2 vUv;\n\n                uniform sampler2D maskTexture;\n                uniform vec2 texSize;\n                uniform vec3 visibleEdgeColor;\n                uniform vec3 hiddenEdgeColor;\n\n                void main() {\n                    vec2 invSize = 1.0 / texSize;\n                    vec4 uvOffset = vec4(1.0, 0.0, 0.0, 1.0) * vec4(invSize, invSize);\n                    vec4 c1 = texture2D(maskTexture, vUv + uvOffset.xy);\n                    vec4 c2 = texture2D(maskTexture, vUv - uvOffset.xy);\n                    vec4 c3 = texture2D(maskTexture, vUv + uvOffset.yw);\n                    vec4 c4 = texture2D(maskTexture, vUv - uvOffset.yw);\n                    float diff1 = (c1.r - c2.r)*0.5;\n                    float diff2 = (c3.r - c4.r)*0.5;\n                    float d = length(vec2(diff1, diff2));\n                    float a1 = min(c1.g, c2.g);\n                    float a2 = min(c3.g, c4.g);\n                    float visibilityFactor = min(a1, a2);\n                    vec3 edgeColor = 1.0 - visibilityFactor > 0.001 ? visibleEdgeColor : hiddenEdgeColor;\n                    gl_FragColor = vec4(edgeColor, 1.0) * vec4(d);\n                }"
+      });
+    }
+  }, {
+    key: "getSeperableBlurMaterial",
+    value: function getSeperableBlurMaterial(maxRadius) {
+      return new ShaderMaterial({
+        defines: {
+          'MAX_RADIUS': maxRadius
+        },
+        uniforms: {
+          'colorTexture': {
+            value: null
+          },
+          'texSize': {
+            value: new Vector2(0.5, 0.5)
+          },
+          'direction': {
+            value: new Vector2(0.5, 0.5)
+          },
+          'kernelRadius': {
+            value: 1.0
+          }
+        },
+        vertexShader: "varying vec2 vUv;\n\n                void main() {\n                    vUv = uv;\n                    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n                }",
+        fragmentShader: "#include <common>\n                varying vec2 vUv;\n                uniform sampler2D colorTexture;\n                uniform vec2 texSize;\n                uniform vec2 direction;\n                uniform float kernelRadius;\n\n                float gaussianPdf(in float x, in float sigma) {\n                    return 0.39894 * exp(-0.5 * x * x/(sigma * sigma))/sigma;\n                }\n\n                void main() {\n                    vec2 invSize = 1.0 / texSize;\n                    float weightSum = gaussianPdf(0.0, kernelRadius);\n                    vec4 diffuseSum = texture2D(colorTexture, vUv) * weightSum;\n                    vec2 delta = direction * invSize * kernelRadius/float(MAX_RADIUS);\n                    vec2 uvOffset = delta;\n                    for(int i = 1; i <= MAX_RADIUS; i ++) {\n                        float w = gaussianPdf(uvOffset.x, kernelRadius);\n                        vec4 sample1 = texture2D(colorTexture, vUv + uvOffset);\n                        vec4 sample2 = texture2D(colorTexture, vUv - uvOffset);\n                        diffuseSum += ((sample1 + sample2) * w);\n                        weightSum += (2.0 * w);\n                        uvOffset += delta;\n                    }\n                    gl_FragColor = diffuseSum/weightSum;\n                }"
+      });
+    }
+  }, {
+    key: "getOverlayMaterial",
+    value: function getOverlayMaterial() {
+      return new ShaderMaterial({
+        uniforms: {
+          'maskTexture': {
+            value: null
+          },
+          'edgeTexture1': {
+            value: null
+          },
+          'edgeTexture2': {
+            value: null
+          },
+          'patternTexture': {
+            value: null
+          },
+          'edgeStrength': {
+            value: 1.0
+          },
+          'edgeGlow': {
+            value: 1.0
+          },
+          'usePatternTexture': {
+            value: 0.0
+          }
+        },
+        vertexShader: "varying vec2 vUv;\n\n                void main() {\n                    vUv = uv;\n                    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n                }",
+        fragmentShader: "varying vec2 vUv;\n\n                uniform sampler2D maskTexture;\n                uniform sampler2D edgeTexture1;\n                uniform sampler2D edgeTexture2;\n                uniform sampler2D patternTexture;\n                uniform float edgeStrength;\n                uniform float edgeGlow;\n                uniform bool usePatternTexture;\n\n                void main() {\n                    vec4 edgeValue1 = texture2D(edgeTexture1, vUv);\n                    vec4 edgeValue2 = texture2D(edgeTexture2, vUv);\n                    vec4 maskColor = texture2D(maskTexture, vUv);\n                    vec4 patternColor = texture2D(patternTexture, 6.0 * vUv);\n                    float visibilityFactor = 1.0 - maskColor.g > 0.0 ? 1.0 : 0.5;\n                    vec4 edgeValue = edgeValue1 + edgeValue2 * edgeGlow;\n                    vec4 finalColor = edgeStrength * maskColor.r * edgeValue;\n                    if(usePatternTexture)\n                        finalColor += + visibilityFactor * (1.0 - maskColor.r) * (1.0 - patternColor.r);\n                    gl_FragColor = finalColor;\n                }",
+        blending: AdditiveBlending,
+        depthTest: false,
+        depthWrite: false,
+        transparent: true
+      });
+    }
+  }]);
+
+  return SelectiveOutline;
+}(Pass);/**
  * RGB Shift Shader
  * Shifts red and blue channels from center in opposite directions
  * Ported from http://kriss.cx/tom/2009/05/rgb-shift/
@@ -76213,7 +76685,7 @@ var DigitalGlitch = {
       vertexShader: DigitalGlitch.vertexShader,
       fragmentShader: DigitalGlitch.fragmentShader
     });
-    _this.fsQuad = new Pass.FullScreenQuad(_this.material);
+    _this.fsQuad = new FullScreenQuad(_this.material);
     _this.goWild = false;
     _this.curF = 0;
 
@@ -76858,6 +77330,9 @@ var OutlineEffect = /*#__PURE__*/function () {
     }), _defineProperty(_this$map, EFFECTS.DEPTH_OF_FIELD, {
       effect: DepthOfField,
       isClass: true
+    }), _defineProperty(_this$map, EFFECTS.SELECTIVE_OUTLINE, {
+      effect: SelectiveOutline,
+      isClass: true
     }), _defineProperty(_this$map, EFFECTS.GLITCH, {
       effect: GlitchEffect,
       isClass: true

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mage-engine",
-    "version": "3.16.6",
+    "version": "3.16.7",
     "description": "A WebGL Javascript Game Engine, built on top of THREE.js and many other libraries.",
     "main": "dist/mage.js",
     "author": {