opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/misc/MorphBlendMesh.js

@@ -0,0 +1,283 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.MorphBlendMesh = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.MorphBlendMesh = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var MorphBlendMesh = /*#__PURE__*/function (_Mesh) {
+    _inherits(MorphBlendMesh, _Mesh);
+
+    var _super = _createSuper(MorphBlendMesh);
+
+    function MorphBlendMesh(geometry, material) {
+      var _this;
+
+      _classCallCheck(this, MorphBlendMesh);
+
+      _this = _super.call(this, geometry, material);
+      _this.animationsMap = {};
+      _this.animationsList = []; // prepare default animation
+      // (all frames played together in 1 second)
+
+      var numFrames = Object.keys(_this.morphTargetDictionary).length;
+      var name = '__default';
+      var startFrame = 0;
+      var endFrame = numFrames - 1;
+      var fps = numFrames / 1;
+
+      _this.createAnimation(name, startFrame, endFrame, fps);
+
+      _this.setAnimationWeight(name, 1);
+
+      return _this;
+    }
+
+    _createClass(MorphBlendMesh, [{
+      key: "createAnimation",
+      value: function createAnimation(name, start, end, fps) {
+        var animation = {
+          start: start,
+          end: end,
+          length: end - start + 1,
+          fps: fps,
+          duration: (end - start) / fps,
+          lastFrame: 0,
+          currentFrame: 0,
+          active: false,
+          time: 0,
+          direction: 1,
+          weight: 1,
+          directionBackwards: false,
+          mirroredLoop: false
+        };
+        this.animationsMap[name] = animation;
+        this.animationsList.push(animation);
+      }
+    }, {
+      key: "autoCreateAnimations",
+      value: function autoCreateAnimations(fps) {
+        var pattern = /([a-z]+)_?(\d+)/i;
+        var firstAnimation;
+        var frameRanges = {};
+        var i = 0;
+
+        for (var key in this.morphTargetDictionary) {
+          var chunks = key.match(pattern);
+
+          if (chunks && chunks.length > 1) {
+            var name = chunks[1];
+            if (!frameRanges[name]) frameRanges[name] = {
+              start: Infinity,
+              end: -Infinity
+            };
+            var range = frameRanges[name];
+            if (i < range.start) range.start = i;
+            if (i > range.end) range.end = i;
+            if (!firstAnimation) firstAnimation = name;
+          }
+
+          i++;
+        }
+
+        for (var _name in frameRanges) {
+          var _range = frameRanges[_name];
+          this.createAnimation(_name, _range.start, _range.end, fps);
+        }
+
+        this.firstAnimation = firstAnimation;
+      }
+    }, {
+      key: "setAnimationDirectionForward",
+      value: function setAnimationDirectionForward(name) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.direction = 1;
+          animation.directionBackwards = false;
+        }
+      }
+    }, {
+      key: "setAnimationDirectionBackward",
+      value: function setAnimationDirectionBackward(name) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.direction = -1;
+          animation.directionBackwards = true;
+        }
+      }
+    }, {
+      key: "setAnimationFPS",
+      value: function setAnimationFPS(name, fps) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.fps = fps;
+          animation.duration = (animation.end - animation.start) / animation.fps;
+        }
+      }
+    }, {
+      key: "setAnimationDuration",
+      value: function setAnimationDuration(name, duration) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.duration = duration;
+          animation.fps = (animation.end - animation.start) / animation.duration;
+        }
+      }
+    }, {
+      key: "setAnimationWeight",
+      value: function setAnimationWeight(name, weight) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.weight = weight;
+        }
+      }
+    }, {
+      key: "setAnimationTime",
+      value: function setAnimationTime(name, time) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.time = time;
+        }
+      }
+    }, {
+      key: "getAnimationTime",
+      value: function getAnimationTime(name) {
+        var time = 0;
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          time = animation.time;
+        }
+
+        return time;
+      }
+    }, {
+      key: "getAnimationDuration",
+      value: function getAnimationDuration(name) {
+        var duration = -1;
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          duration = animation.duration;
+        }
+
+        return duration;
+      }
+    }, {
+      key: "playAnimation",
+      value: function playAnimation(name) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.time = 0;
+          animation.active = true;
+        } else {
+          console.warn('THREE.MorphBlendMesh: animation[' + name + '] undefined in .playAnimation()');
+        }
+      }
+    }, {
+      key: "stopAnimation",
+      value: function stopAnimation(name) {
+        var animation = this.animationsMap[name];
+
+        if (animation) {
+          animation.active = false;
+        }
+      }
+    }, {
+      key: "update",
+      value: function update(delta) {
+        for (var i = 0, il = this.animationsList.length; i < il; i++) {
+          var animation = this.animationsList[i];
+          if (!animation.active) continue;
+          var frameTime = animation.duration / animation.length;
+          animation.time += animation.direction * delta;
+
+          if (animation.mirroredLoop) {
+            if (animation.time > animation.duration || animation.time < 0) {
+              animation.direction *= -1;
+
+              if (animation.time > animation.duration) {
+                animation.time = animation.duration;
+                animation.directionBackwards = true;
+              }
+
+              if (animation.time < 0) {
+                animation.time = 0;
+                animation.directionBackwards = false;
+              }
+            }
+          } else {
+            animation.time = animation.time % animation.duration;
+            if (animation.time < 0) animation.time += animation.duration;
+          }
+
+          var keyframe = animation.start + _three.MathUtils.clamp(Math.floor(animation.time / frameTime), 0, animation.length - 1);
+
+          var weight = animation.weight;
+
+          if (keyframe !== animation.currentFrame) {
+            this.morphTargetInfluences[animation.lastFrame] = 0;
+            this.morphTargetInfluences[animation.currentFrame] = 1 * weight;
+            this.morphTargetInfluences[keyframe] = 0;
+            animation.lastFrame = animation.currentFrame;
+            animation.currentFrame = keyframe;
+          }
+
+          var mix = animation.time % frameTime / frameTime;
+          if (animation.directionBackwards) mix = 1 - mix;
+
+          if (animation.currentFrame !== animation.lastFrame) {
+            this.morphTargetInfluences[animation.currentFrame] = mix * weight;
+            this.morphTargetInfluences[animation.lastFrame] = (1 - mix) * weight;
+          } else {
+            this.morphTargetInfluences[animation.currentFrame] = weight;
+          }
+        }
+      }
+    }]);
+
+    return MorphBlendMesh;
+  }(_three.Mesh);
+
+  _exports.MorphBlendMesh = MorphBlendMesh;
+});

data/lib-opal/js_wrap/three/misc/ProgressiveLightMap.js

@@ -0,0 +1,324 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../libs/potpack.module.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../libs/potpack.module.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.potpackModule);
+    global.ProgressiveLightMap = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, THREE, _potpackModule) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ProgressiveLightMap = void 0;
+  THREE = _interopRequireWildcard(THREE);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  /**
+   * Progressive Light Map Accumulator, by [zalo](https://github.com/zalo/)
+   *
+   * To use, simply construct a `ProgressiveLightMap` object,
+   * `plmap.addObjectsToLightMap(object)` an array of semi-static
+   * objects and lights to the class once, and then call
+   * `plmap.update(camera)` every frame to begin accumulating
+   * lighting samples.
+   *
+   * This should begin accumulating lightmaps which apply to
+   * your objects, so you can start jittering lighting to achieve
+   * the texture-space effect you're looking for.
+   *
+   * @param {WebGLRenderer} renderer A WebGL Rendering Context
+   * @param {number} res The side-long dimension of you total lightmap
+   */
+  var ProgressiveLightMap = /*#__PURE__*/function () {
+    function ProgressiveLightMap(renderer) {
+      var _this = this;
+
+      var res = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1024;
+
+      _classCallCheck(this, ProgressiveLightMap);
+
+      this.renderer = renderer;
+      this.res = res;
+      this.lightMapContainers = [];
+      this.compiled = false;
+      this.scene = new THREE.Scene();
+      this.scene.background = null;
+      this.tinyTarget = new THREE.WebGLRenderTarget(1, 1);
+      this.buffer1Active = false;
+      this.firstUpdate = true;
+      this.warned = false; // Create the Progressive LightMap Texture
+
+      var format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? THREE.HalfFloatType : THREE.FloatType;
+      this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, {
+        type: format
+      });
+      this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, {
+        type: format
+      }); // Inject some spicy new logic into a standard phong material
+
+      this.uvMat = new THREE.MeshPhongMaterial();
+      this.uvMat.uniforms = {};
+
+      this.uvMat.onBeforeCompile = function (shader) {
+        // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
+        shader.vertexShader = '#define USE_LIGHTMAP\n' + shader.vertexShader.slice(0, -1) + '	gl_Position = vec4((uv2 - 0.5) * 2.0, 1.0, 1.0); }'; // Fragment Shader: Set Pixels to average in the Previous frame's Shadows
+
+        var bodyStart = shader.fragmentShader.indexOf('void main() {');
+        shader.fragmentShader = 'varying vec2 vUv2;\n' + shader.fragmentShader.slice(0, bodyStart) + '	uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' + shader.fragmentShader.slice(bodyStart - 1, -1) + "\nvec3 texelOld = texture2D(previousShadowMap, vUv2).rgb;\n\t\t\t\tgl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/averagingWindow);\n\t\t\t}"; // Set the Previous Frame's Texture Buffer and Averaging Window
+
+        shader.uniforms.previousShadowMap = {
+          value: _this.progressiveLightMap1.texture
+        };
+        shader.uniforms.averagingWindow = {
+          value: 100
+        };
+        _this.uvMat.uniforms = shader.uniforms; // Set the new Shader to this
+
+        _this.uvMat.userData.shader = shader;
+        _this.compiled = true;
+      };
+    }
+    /**
+     * Sets these objects' materials' lightmaps and modifies their uv2's.
+     * @param {Object3D} objects An array of objects and lights to set up your lightmap.
+     */
+
+
+    _createClass(ProgressiveLightMap, [{
+      key: "addObjectsToLightMap",
+      value: function addObjectsToLightMap(objects) {
+        // Prepare list of UV bounding boxes for packing later...
+        this.uv_boxes = [];
+        var padding = 3 / this.res;
+
+        for (var ob = 0; ob < objects.length; ob++) {
+          var object = objects[ob]; // If this object is a light, simply add it to the internal scene
+
+          if (object.isLight) {
+            this.scene.attach(object);
+            continue;
+          }
+
+          if (!object.geometry.hasAttribute('uv')) {
+            console.warn('All lightmap objects need UVs!');
+            continue;
+          }
+
+          if (this.blurringPlane == null) {
+            this._initializeBlurPlane(this.res, this.progressiveLightMap1);
+          } // Apply the lightmap to the object
+
+
+          object.material.lightMap = this.progressiveLightMap2.texture;
+          object.material.dithering = true;
+          object.castShadow = true;
+          object.receiveShadow = true;
+          object.renderOrder = 1000 + ob; // Prepare UV boxes for potpack
+          // TODO: Size these by object surface area
+
+          this.uv_boxes.push({
+            w: 1 + padding * 2,
+            h: 1 + padding * 2,
+            index: ob
+          });
+          this.lightMapContainers.push({
+            basicMat: object.material,
+            object: object
+          });
+          this.compiled = false;
+        } // Pack the objects' lightmap UVs into the same global space
+
+
+        var dimensions = (0, _potpackModule.potpack)(this.uv_boxes);
+        this.uv_boxes.forEach(function (box) {
+          var uv2 = objects[box.index].geometry.getAttribute('uv').clone();
+
+          for (var i = 0; i < uv2.array.length; i += uv2.itemSize) {
+            uv2.array[i] = (uv2.array[i] + box.x + padding) / dimensions.w;
+            uv2.array[i + 1] = (uv2.array[i + 1] + box.y + padding) / dimensions.h;
+          }
+
+          objects[box.index].geometry.setAttribute('uv2', uv2);
+          objects[box.index].geometry.getAttribute('uv2').needsUpdate = true;
+        });
+      }
+      /**
+       * This function renders each mesh one at a time into their respective surface maps
+       * @param {Camera} camera Standard Rendering Camera
+       * @param {number} blendWindow When >1, samples will accumulate over time.
+       * @param {boolean} blurEdges  Whether to fix UV Edges via blurring
+       */
+
+    }, {
+      key: "update",
+      value: function update(camera) {
+        var blendWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+        var blurEdges = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+
+        if (this.blurringPlane == null) {
+          return;
+        } // Store the original Render Target
+
+
+        var oldTarget = this.renderer.getRenderTarget(); // The blurring plane applies blur to the seams of the lightmap
+
+        this.blurringPlane.visible = blurEdges; // Steal the Object3D from the real world to our special dimension
+
+        for (var l = 0; l < this.lightMapContainers.length; l++) {
+          this.lightMapContainers[l].object.oldScene = this.lightMapContainers[l].object.parent;
+          this.scene.attach(this.lightMapContainers[l].object);
+        } // Render once normally to initialize everything
+
+
+        if (this.firstUpdate) {
+          this.renderer.setRenderTarget(this.tinyTarget); // Tiny for Speed
+
+          this.renderer.render(this.scene, camera);
+          this.firstUpdate = false;
+        } // Set each object's material to the UV Unwrapped Surface Mapping Version
+
+
+        for (var _l = 0; _l < this.lightMapContainers.length; _l++) {
+          this.uvMat.uniforms.averagingWindow = {
+            value: blendWindow
+          };
+          this.lightMapContainers[_l].object.material = this.uvMat;
+          this.lightMapContainers[_l].object.oldFrustumCulled = this.lightMapContainers[_l].object.frustumCulled;
+          this.lightMapContainers[_l].object.frustumCulled = false;
+        } // Ping-pong two surface buffers for reading/writing
+
+
+        var activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;
+        var inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1; // Render the object's surface maps
+
+        this.renderer.setRenderTarget(activeMap);
+        this.uvMat.uniforms.previousShadowMap = {
+          value: inactiveMap.texture
+        };
+        this.blurringPlane.material.uniforms.previousShadowMap = {
+          value: inactiveMap.texture
+        };
+        this.buffer1Active = !this.buffer1Active;
+        this.renderer.render(this.scene, camera); // Restore the object's Real-time Material and add it back to the original world
+
+        for (var _l2 = 0; _l2 < this.lightMapContainers.length; _l2++) {
+          this.lightMapContainers[_l2].object.frustumCulled = this.lightMapContainers[_l2].object.oldFrustumCulled;
+          this.lightMapContainers[_l2].object.material = this.lightMapContainers[_l2].basicMat;
+
+          this.lightMapContainers[_l2].object.oldScene.attach(this.lightMapContainers[_l2].object);
+        } // Restore the original Render Target
+
+
+        this.renderer.setRenderTarget(oldTarget);
+      }
+      /** DEBUG
+       * Draw the lightmap in the main scene.  Call this after adding the objects to it.
+       * @param {boolean} visible Whether the debug plane should be visible
+       * @param {Vector3} position Where the debug plane should be drawn
+      */
+
+    }, {
+      key: "showDebugLightmap",
+      value: function showDebugLightmap(visible) {
+        var position = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+
+        if (this.lightMapContainers.length == 0) {
+          if (!this.warned) {
+            console.warn('Call this after adding the objects!');
+            this.warned = true;
+          }
+
+          return;
+        }
+
+        if (this.labelMesh == null) {
+          this.labelMaterial = new THREE.MeshBasicMaterial({
+            map: this.progressiveLightMap1.texture,
+            side: THREE.DoubleSide
+          });
+          this.labelPlane = new THREE.PlaneGeometry(100, 100);
+          this.labelMesh = new THREE.Mesh(this.labelPlane, this.labelMaterial);
+          this.labelMesh.position.y = 250;
+          this.lightMapContainers[0].object.parent.add(this.labelMesh);
+        }
+
+        if (position != undefined) {
+          this.labelMesh.position.copy(position);
+        }
+
+        this.labelMesh.visible = visible;
+      }
+      /**
+       * INTERNAL Creates the Blurring Plane
+       * @param {number} res The square resolution of this object's lightMap.
+       * @param {WebGLRenderTexture} lightMap The lightmap to initialize the plane with.
+       */
+
+    }, {
+      key: "_initializeBlurPlane",
+      value: function _initializeBlurPlane(res) {
+        var _this2 = this;
+
+        var lightMap = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+        var blurMaterial = new THREE.MeshBasicMaterial();
+        blurMaterial.uniforms = {
+          previousShadowMap: {
+            value: null
+          },
+          pixelOffset: {
+            value: 1.0 / res
+          },
+          polygonOffset: true,
+          polygonOffsetFactor: -1,
+          polygonOffsetUnits: 3.0
+        };
+
+        blurMaterial.onBeforeCompile = function (shader) {
+          // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
+          shader.vertexShader = '#define USE_UV\n' + shader.vertexShader.slice(0, -1) + '	gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }'; // Fragment Shader: Set Pixels to 9-tap box blur the current frame's Shadows
+
+          var bodyStart = shader.fragmentShader.indexOf('void main() {');
+          shader.fragmentShader = '#define USE_UV\n' + shader.fragmentShader.slice(0, bodyStart) + '	uniform sampler2D previousShadowMap;\n	uniform float pixelOffset;\n' + shader.fragmentShader.slice(bodyStart - 1, -1) + "\tgl_FragColor.rgb = (\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2( pixelOffset,  0.0        )).rgb +\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2( 0.0        ,  pixelOffset)).rgb +\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2( 0.0        , -pixelOffset)).rgb +\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2(-pixelOffset,  0.0        )).rgb +\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2( pixelOffset,  pixelOffset)).rgb +\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2(-pixelOffset,  pixelOffset)).rgb +\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2( pixelOffset, -pixelOffset)).rgb +\n\t\t\t\t\t\t\t\t\ttexture2D(previousShadowMap, vUv + vec2(-pixelOffset, -pixelOffset)).rgb)/8.0;\n\t\t\t\t}"; // Set the LightMap Accumulation Buffer
+
+          shader.uniforms.previousShadowMap = {
+            value: lightMap.texture
+          };
+          shader.uniforms.pixelOffset = {
+            value: 0.5 / res
+          };
+          blurMaterial.uniforms = shader.uniforms; // Set the new Shader to this
+
+          blurMaterial.userData.shader = shader;
+          _this2.compiled = true;
+        };
+
+        this.blurringPlane = new THREE.Mesh(new THREE.PlaneBufferGeometry(1, 1), blurMaterial);
+        this.blurringPlane.name = 'Blurring Plane';
+        this.blurringPlane.frustumCulled = false;
+        this.blurringPlane.renderOrder = 0;
+        this.blurringPlane.material.depthWrite = false;
+        this.scene.add(this.blurringPlane);
+      }
+    }]);
+
+    return ProgressiveLightMap;
+  }();
+
+  _exports.ProgressiveLightMap = ProgressiveLightMap;
+});