opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/nodes/utils/VelocityNode.js

@@ -0,0 +1,181 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../inputs/Vector3Node.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../inputs/Vector3Node.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.Vector3Node);
+    global.VelocityNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _Vector3Node2) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.VelocityNode = 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 _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  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 VelocityNode = /*#__PURE__*/function (_Vector3Node) {
+    _inherits(VelocityNode, _Vector3Node);
+
+    var _super = _createSuper(VelocityNode);
+
+    function VelocityNode(target, params) {
+      var _this;
+
+      _classCallCheck(this, VelocityNode);
+
+      _this = _super.call(this);
+      _this.params = {};
+      _this.velocity = new _three.Vector3();
+
+      _this.setTarget(target);
+
+      _this.setParams(params);
+
+      return _this;
+    }
+
+    _createClass(VelocityNode, [{
+      key: "getReadonly",
+      value: function
+        /*builder*/
+      getReadonly() {
+        return false;
+      }
+    }, {
+      key: "setParams",
+      value: function setParams(params) {
+        switch (this.params.type) {
+          case 'elastic':
+            delete this.moment;
+            delete this.speed;
+            delete this.springVelocity;
+            delete this.lastVelocity;
+            break;
+        }
+
+        this.params = params || {};
+
+        switch (this.params.type) {
+          case 'elastic':
+            this.moment = new _three.Vector3();
+            this.speed = new _three.Vector3();
+            this.springVelocity = new _three.Vector3();
+            this.lastVelocity = new _three.Vector3();
+            break;
+        }
+      }
+    }, {
+      key: "setTarget",
+      value: function setTarget(target) {
+        if (this.target) {
+          delete this.position;
+          delete this.oldPosition;
+        }
+
+        this.target = target;
+
+        if (target) {
+          this.position = target.getWorldPosition(this.position || new _three.Vector3());
+          this.oldPosition = this.position.clone();
+        }
+      }
+    }, {
+      key: "updateFrameVelocity",
+      value: function
+        /*frame*/
+      updateFrameVelocity() {
+        if (this.target) {
+          this.position = this.target.getWorldPosition(this.position || new _three.Vector3());
+          this.velocity.subVectors(this.position, this.oldPosition);
+          this.oldPosition.copy(this.position);
+        }
+      }
+    }, {
+      key: "updateFrame",
+      value: function updateFrame(frame) {
+        this.updateFrameVelocity(frame);
+
+        switch (this.params.type) {
+          case 'elastic':
+            // convert to real scale: 0 at 1 values
+            var deltaFps = frame.delta * (this.params.fps || 60);
+            var spring = Math.pow(this.params.spring, deltaFps),
+                damping = Math.pow(this.params.damping, deltaFps); // fix relative frame-rate
+
+            this.velocity.multiplyScalar(Math.exp(-this.params.damping * deltaFps)); // elastic
+
+            this.velocity.add(this.springVelocity);
+            this.velocity.add(this.speed.multiplyScalar(damping).multiplyScalar(1 - spring)); // speed
+
+            this.speed.subVectors(this.velocity, this.lastVelocity); // spring velocity
+
+            this.springVelocity.add(this.speed);
+            this.springVelocity.multiplyScalar(spring); // moment
+
+            this.moment.add(this.springVelocity); // damping
+
+            this.moment.multiplyScalar(damping);
+            this.lastVelocity.copy(this.velocity);
+            this.value.copy(this.moment);
+            break;
+
+          default:
+            this.value.copy(this.velocity);
+        }
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(VelocityNode.prototype), "copy", this).call(this, source);
+
+        if (source.target) this.setTarget(source.target);
+        this.setParams(source.params);
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = _get(_getPrototypeOf(VelocityNode.prototype), "toJSON", this).call(this, meta);
+
+        if (this.target) data.target = this.target.uuid; // clone params
+
+        data.params = JSON.parse(JSON.stringify(this.params));
+        return data;
+      }
+    }]);
+
+    return VelocityNode;
+  }(_Vector3Node2.Vector3Node);
+
+  _exports.VelocityNode = VelocityNode;
+  VelocityNode.prototype.nodeType = 'Velocity';
+});

data/lib-opal/js_wrap/three/objects/Lensflare.js

@@ -0,0 +1,285 @@
+(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.Lensflare = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.LensflareElement = _exports.Lensflare = void 0;
+
+  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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 Lensflare = /*#__PURE__*/function (_Mesh) {
+    _inherits(Lensflare, _Mesh);
+
+    var _super = _createSuper(Lensflare);
+
+    function Lensflare() {
+      var _this;
+
+      _classCallCheck(this, Lensflare);
+
+      _this = _super.call(this, Lensflare.Geometry, new _three.MeshBasicMaterial({
+        opacity: 0,
+        transparent: true
+      }));
+      _this.type = 'Lensflare';
+      _this.frustumCulled = false;
+      _this.renderOrder = Infinity; //
+
+      var positionScreen = new _three.Vector3();
+      var positionView = new _three.Vector3(); // textures
+
+      var tempMap = new _three.DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, _three.RGBFormat);
+      tempMap.minFilter = _three.NearestFilter;
+      tempMap.magFilter = _three.NearestFilter;
+      tempMap.wrapS = _three.ClampToEdgeWrapping;
+      tempMap.wrapT = _three.ClampToEdgeWrapping;
+      var occlusionMap = new _three.DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, _three.RGBFormat);
+      occlusionMap.minFilter = _three.NearestFilter;
+      occlusionMap.magFilter = _three.NearestFilter;
+      occlusionMap.wrapS = _three.ClampToEdgeWrapping;
+      occlusionMap.wrapT = _three.ClampToEdgeWrapping; // material
+
+      var geometry = Lensflare.Geometry;
+      var material1a = new _three.RawShaderMaterial({
+        uniforms: {
+          'scale': {
+            value: null
+          },
+          'screenPosition': {
+            value: null
+          }
+        },
+        vertexShader:
+        /* glsl */
+        "\n\n\t\t\t\tprecision highp float;\n\n\t\t\t\tuniform vec3 screenPosition;\n\t\t\t\tuniform vec2 scale;\n\n\t\t\t\tattribute vec3 position;\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tgl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );\n\n\t\t\t\t}",
+        fragmentShader:
+        /* glsl */
+        "\n\n\t\t\t\tprecision highp float;\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tgl_FragColor = vec4( 1.0, 0.0, 1.0, 1.0 );\n\n\t\t\t\t}",
+        depthTest: true,
+        depthWrite: false,
+        transparent: false
+      });
+      var material1b = new _three.RawShaderMaterial({
+        uniforms: {
+          'map': {
+            value: tempMap
+          },
+          'scale': {
+            value: null
+          },
+          'screenPosition': {
+            value: null
+          }
+        },
+        vertexShader:
+        /* glsl */
+        "\n\n\t\t\t\tprecision highp float;\n\n\t\t\t\tuniform vec3 screenPosition;\n\t\t\t\tuniform vec2 scale;\n\n\t\t\t\tattribute vec3 position;\n\t\t\t\tattribute vec2 uv;\n\n\t\t\t\tvarying vec2 vUV;\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tvUV = uv;\n\n\t\t\t\t\tgl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );\n\n\t\t\t\t}",
+        fragmentShader:
+        /* glsl */
+        "\n\n\t\t\t\tprecision highp float;\n\n\t\t\t\tuniform sampler2D map;\n\n\t\t\t\tvarying vec2 vUV;\n\n\t\t\t\tvoid main() {\n\n\t\t\t\t\tgl_FragColor = texture2D( map, vUV );\n\n\t\t\t\t}",
+        depthTest: false,
+        depthWrite: false,
+        transparent: false
+      }); // the following object is used for occlusionMap generation
+
+      var mesh1 = new _three.Mesh(geometry, material1a); //
+
+      var elements = [];
+      var shader = LensflareElement.Shader;
+      var material2 = new _three.RawShaderMaterial({
+        uniforms: {
+          'map': {
+            value: null
+          },
+          'occlusionMap': {
+            value: occlusionMap
+          },
+          'color': {
+            value: new _three.Color(0xffffff)
+          },
+          'scale': {
+            value: new _three.Vector2()
+          },
+          'screenPosition': {
+            value: new _three.Vector3()
+          }
+        },
+        vertexShader: shader.vertexShader,
+        fragmentShader: shader.fragmentShader,
+        blending: _three.AdditiveBlending,
+        transparent: true,
+        depthWrite: false
+      });
+      var mesh2 = new _three.Mesh(geometry, material2);
+
+      _this.addElement = function (element) {
+        elements.push(element);
+      }; //
+
+
+      var scale = new _three.Vector2();
+      var screenPositionPixels = new _three.Vector2();
+      var validArea = new _three.Box2();
+      var viewport = new _three.Vector4();
+
+      _this.onBeforeRender = function (renderer, scene, camera) {
+        renderer.getCurrentViewport(viewport);
+        var invAspect = viewport.w / viewport.z;
+        var halfViewportWidth = viewport.z / 2.0;
+        var halfViewportHeight = viewport.w / 2.0;
+        var size = 16 / viewport.w;
+        scale.set(size * invAspect, size);
+        validArea.min.set(viewport.x, viewport.y);
+        validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16)); // calculate position in screen space
+
+        positionView.setFromMatrixPosition(this.matrixWorld);
+        positionView.applyMatrix4(camera.matrixWorldInverse);
+        if (positionView.z > 0) return; // lensflare is behind the camera
+
+        positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix); // horizontal and vertical coordinate of the lower left corner of the pixels to copy
+
+        screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8;
+        screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8; // screen cull
+
+        if (validArea.containsPoint(screenPositionPixels)) {
+          // save current RGB to temp texture
+          renderer.copyFramebufferToTexture(screenPositionPixels, tempMap); // render pink quad
+
+          var uniforms = material1a.uniforms;
+          uniforms['scale'].value = scale;
+          uniforms['screenPosition'].value = positionScreen;
+          renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null); // copy result to occlusionMap
+
+          renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap); // restore graphics
+
+          uniforms = material1b.uniforms;
+          uniforms['scale'].value = scale;
+          uniforms['screenPosition'].value = positionScreen;
+          renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null); // render elements
+
+          var vecX = -positionScreen.x * 2;
+          var vecY = -positionScreen.y * 2;
+
+          for (var i = 0, l = elements.length; i < l; i++) {
+            var element = elements[i];
+            var _uniforms = material2.uniforms;
+
+            _uniforms['color'].value.copy(element.color);
+
+            _uniforms['map'].value = element.texture;
+            _uniforms['screenPosition'].value.x = positionScreen.x + vecX * element.distance;
+            _uniforms['screenPosition'].value.y = positionScreen.y + vecY * element.distance;
+            size = element.size / viewport.w;
+
+            var _invAspect = viewport.w / viewport.z;
+
+            _uniforms['scale'].value.set(size * _invAspect, size);
+
+            material2.uniformsNeedUpdate = true;
+            renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null);
+          }
+        }
+      };
+
+      _this.dispose = function () {
+        material1a.dispose();
+        material1b.dispose();
+        material2.dispose();
+        tempMap.dispose();
+        occlusionMap.dispose();
+
+        for (var i = 0, l = elements.length; i < l; i++) {
+          elements[i].texture.dispose();
+        }
+      };
+
+      return _this;
+    }
+
+    return _createClass(Lensflare);
+  }(_three.Mesh);
+
+  _exports.Lensflare = Lensflare;
+  Lensflare.prototype.isLensflare = true; //
+
+  var LensflareElement = /*#__PURE__*/_createClass(function LensflareElement(texture) {
+    var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    var distance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    var color = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new _three.Color(0xffffff);
+
+    _classCallCheck(this, LensflareElement);
+
+    this.texture = texture;
+    this.size = size;
+    this.distance = distance;
+    this.color = color;
+  });
+
+  _exports.LensflareElement = LensflareElement;
+  LensflareElement.Shader = {
+    uniforms: {
+      'map': {
+        value: null
+      },
+      'occlusionMap': {
+        value: null
+      },
+      'color': {
+        value: null
+      },
+      'scale': {
+        value: null
+      },
+      'screenPosition': {
+        value: null
+      }
+    },
+    vertexShader:
+    /* glsl */
+    "\n\n\t\tprecision highp float;\n\n\t\tuniform vec3 screenPosition;\n\t\tuniform vec2 scale;\n\n\t\tuniform sampler2D occlusionMap;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\n\t\tvarying vec2 vUV;\n\t\tvarying float vVisibility;\n\n\t\tvoid main() {\n\n\t\t\tvUV = uv;\n\n\t\t\tvec2 pos = position.xy;\n\n\t\t\tvec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );\n\t\t\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );\n\n\t\t\tvVisibility =        visibility.r / 9.0;\n\t\t\tvVisibility *= 1.0 - visibility.g / 9.0;\n\t\t\tvVisibility *=       visibility.b / 9.0;\n\n\t\t\tgl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );\n\n\t\t}",
+    fragmentShader:
+    /* glsl */
+    "\n\n\t\tprecision highp float;\n\n\t\tuniform sampler2D map;\n\t\tuniform vec3 color;\n\n\t\tvarying vec2 vUV;\n\t\tvarying float vVisibility;\n\n\t\tvoid main() {\n\n\t\t\tvec4 texture = texture2D( map, vUV );\n\t\t\ttexture.a *= vVisibility;\n\t\t\tgl_FragColor = texture;\n\t\t\tgl_FragColor.rgb *= color;\n\n\t\t}"
+  };
+
+  Lensflare.Geometry = function () {
+    var geometry = new _three.BufferGeometry();
+    var float32Array = new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1]);
+    var interleavedBuffer = new _three.InterleavedBuffer(float32Array, 5);
+    geometry.setIndex([0, 1, 2, 0, 2, 3]);
+    geometry.setAttribute('position', new _three.InterleavedBufferAttribute(interleavedBuffer, 3, 0, false));
+    geometry.setAttribute('uv', new _three.InterleavedBufferAttribute(interleavedBuffer, 2, 3, false));
+    return geometry;
+  }();
+});