opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/geometries/DecalGeometry.js

@@ -0,0 +1,302 @@
+(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.DecalGeometry = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.DecalVertex = _exports.DecalGeometry = 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); }
+
+  /**
+   * You can use this geometry to create a decal mesh, that serves different kinds of purposes.
+   * e.g. adding unique details to models, performing dynamic visual environmental changes or covering seams.
+   *
+   * Constructor parameter:
+   *
+   * mesh — Any mesh object
+   * position — Position of the decal projector
+   * orientation — Orientation of the decal projector
+   * size — Size of the decal projector
+   *
+   * reference: http://blog.wolfire.com/2009/06/how-to-project-decals/
+   *
+   */
+  var DecalGeometry = /*#__PURE__*/function (_BufferGeometry) {
+    _inherits(DecalGeometry, _BufferGeometry);
+
+    var _super = _createSuper(DecalGeometry);
+
+    function DecalGeometry(mesh, position, orientation, size) {
+      var _this;
+
+      _classCallCheck(this, DecalGeometry);
+
+      _this = _super.call(this); // buffers
+
+      var vertices = [];
+      var normals = [];
+      var uvs = []; // helpers
+
+      var plane = new _three.Vector3(); // this matrix represents the transformation of the decal projector
+
+      var projectorMatrix = new _three.Matrix4();
+      projectorMatrix.makeRotationFromEuler(orientation);
+      projectorMatrix.setPosition(position);
+      var projectorMatrixInverse = new _three.Matrix4();
+      projectorMatrixInverse.copy(projectorMatrix).invert(); // generate buffers
+
+      generate(); // build geometry
+
+      _this.setAttribute('position', new _three.Float32BufferAttribute(vertices, 3));
+
+      _this.setAttribute('normal', new _three.Float32BufferAttribute(normals, 3));
+
+      _this.setAttribute('uv', new _three.Float32BufferAttribute(uvs, 2));
+
+      function generate() {
+        var decalVertices = [];
+        var vertex = new _three.Vector3();
+        var normal = new _three.Vector3(); // handle different geometry types
+
+        if (mesh.geometry.isGeometry === true) {
+          console.error('THREE.DecalGeometry no longer supports THREE.Geometry. Use BufferGeometry instead.');
+          return;
+        }
+
+        var geometry = mesh.geometry;
+        var positionAttribute = geometry.attributes.position;
+        var normalAttribute = geometry.attributes.normal; // first, create an array of 'DecalVertex' objects
+        // three consecutive 'DecalVertex' objects represent a single face
+        //
+        // this data structure will be later used to perform the clipping
+
+        if (geometry.index !== null) {
+          // indexed BufferGeometry
+          var index = geometry.index;
+
+          for (var i = 0; i < index.count; i++) {
+            vertex.fromBufferAttribute(positionAttribute, index.getX(i));
+            normal.fromBufferAttribute(normalAttribute, index.getX(i));
+            pushDecalVertex(decalVertices, vertex, normal);
+          }
+        } else {
+          // non-indexed BufferGeometry
+          for (var _i = 0; _i < positionAttribute.count; _i++) {
+            vertex.fromBufferAttribute(positionAttribute, _i);
+            normal.fromBufferAttribute(normalAttribute, _i);
+            pushDecalVertex(decalVertices, vertex, normal);
+          }
+        } // second, clip the geometry so that it doesn't extend out from the projector
+
+
+        decalVertices = clipGeometry(decalVertices, plane.set(1, 0, 0));
+        decalVertices = clipGeometry(decalVertices, plane.set(-1, 0, 0));
+        decalVertices = clipGeometry(decalVertices, plane.set(0, 1, 0));
+        decalVertices = clipGeometry(decalVertices, plane.set(0, -1, 0));
+        decalVertices = clipGeometry(decalVertices, plane.set(0, 0, 1));
+        decalVertices = clipGeometry(decalVertices, plane.set(0, 0, -1)); // third, generate final vertices, normals and uvs
+
+        for (var _i2 = 0; _i2 < decalVertices.length; _i2++) {
+          var decalVertex = decalVertices[_i2]; // create texture coordinates (we are still in projector space)
+
+          uvs.push(0.5 + decalVertex.position.x / size.x, 0.5 + decalVertex.position.y / size.y); // transform the vertex back to world space
+
+          decalVertex.position.applyMatrix4(projectorMatrix); // now create vertex and normal buffer data
+
+          vertices.push(decalVertex.position.x, decalVertex.position.y, decalVertex.position.z);
+          normals.push(decalVertex.normal.x, decalVertex.normal.y, decalVertex.normal.z);
+        }
+      }
+
+      function pushDecalVertex(decalVertices, vertex, normal) {
+        // transform the vertex to world space, then to projector space
+        vertex.applyMatrix4(mesh.matrixWorld);
+        vertex.applyMatrix4(projectorMatrixInverse);
+        normal.transformDirection(mesh.matrixWorld);
+        decalVertices.push(new DecalVertex(vertex.clone(), normal.clone()));
+      }
+
+      function clipGeometry(inVertices, plane) {
+        var outVertices = [];
+        var s = 0.5 * Math.abs(size.dot(plane)); // a single iteration clips one face,
+        // which consists of three consecutive 'DecalVertex' objects
+
+        for (var i = 0; i < inVertices.length; i += 3) {
+          var total = 0;
+          var nV1 = void 0;
+          var nV2 = void 0;
+          var nV3 = void 0;
+          var nV4 = void 0;
+          var d1 = inVertices[i + 0].position.dot(plane) - s;
+          var d2 = inVertices[i + 1].position.dot(plane) - s;
+          var d3 = inVertices[i + 2].position.dot(plane) - s;
+          var v1Out = d1 > 0;
+          var v2Out = d2 > 0;
+          var v3Out = d3 > 0; // calculate, how many vertices of the face lie outside of the clipping plane
+
+          total = (v1Out ? 1 : 0) + (v2Out ? 1 : 0) + (v3Out ? 1 : 0);
+
+          switch (total) {
+            case 0:
+              {
+                // the entire face lies inside of the plane, no clipping needed
+                outVertices.push(inVertices[i]);
+                outVertices.push(inVertices[i + 1]);
+                outVertices.push(inVertices[i + 2]);
+                break;
+              }
+
+            case 1:
+              {
+                // one vertex lies outside of the plane, perform clipping
+                if (v1Out) {
+                  nV1 = inVertices[i + 1];
+                  nV2 = inVertices[i + 2];
+                  nV3 = clip(inVertices[i], nV1, plane, s);
+                  nV4 = clip(inVertices[i], nV2, plane, s);
+                }
+
+                if (v2Out) {
+                  nV1 = inVertices[i];
+                  nV2 = inVertices[i + 2];
+                  nV3 = clip(inVertices[i + 1], nV1, plane, s);
+                  nV4 = clip(inVertices[i + 1], nV2, plane, s);
+                  outVertices.push(nV3);
+                  outVertices.push(nV2.clone());
+                  outVertices.push(nV1.clone());
+                  outVertices.push(nV2.clone());
+                  outVertices.push(nV3.clone());
+                  outVertices.push(nV4);
+                  break;
+                }
+
+                if (v3Out) {
+                  nV1 = inVertices[i];
+                  nV2 = inVertices[i + 1];
+                  nV3 = clip(inVertices[i + 2], nV1, plane, s);
+                  nV4 = clip(inVertices[i + 2], nV2, plane, s);
+                }
+
+                outVertices.push(nV1.clone());
+                outVertices.push(nV2.clone());
+                outVertices.push(nV3);
+                outVertices.push(nV4);
+                outVertices.push(nV3.clone());
+                outVertices.push(nV2.clone());
+                break;
+              }
+
+            case 2:
+              {
+                // two vertices lies outside of the plane, perform clipping
+                if (!v1Out) {
+                  nV1 = inVertices[i].clone();
+                  nV2 = clip(nV1, inVertices[i + 1], plane, s);
+                  nV3 = clip(nV1, inVertices[i + 2], plane, s);
+                  outVertices.push(nV1);
+                  outVertices.push(nV2);
+                  outVertices.push(nV3);
+                }
+
+                if (!v2Out) {
+                  nV1 = inVertices[i + 1].clone();
+                  nV2 = clip(nV1, inVertices[i + 2], plane, s);
+                  nV3 = clip(nV1, inVertices[i], plane, s);
+                  outVertices.push(nV1);
+                  outVertices.push(nV2);
+                  outVertices.push(nV3);
+                }
+
+                if (!v3Out) {
+                  nV1 = inVertices[i + 2].clone();
+                  nV2 = clip(nV1, inVertices[i], plane, s);
+                  nV3 = clip(nV1, inVertices[i + 1], plane, s);
+                  outVertices.push(nV1);
+                  outVertices.push(nV2);
+                  outVertices.push(nV3);
+                }
+
+                break;
+              }
+
+            case 3:
+              {
+                // the entire face lies outside of the plane, so let's discard the corresponding vertices
+                break;
+              }
+          }
+        }
+
+        return outVertices;
+      }
+
+      function clip(v0, v1, p, s) {
+        var d0 = v0.position.dot(p) - s;
+        var d1 = v1.position.dot(p) - s;
+        var s0 = d0 / (d0 - d1);
+        var v = new DecalVertex(new _three.Vector3(v0.position.x + s0 * (v1.position.x - v0.position.x), v0.position.y + s0 * (v1.position.y - v0.position.y), v0.position.z + s0 * (v1.position.z - v0.position.z)), new _three.Vector3(v0.normal.x + s0 * (v1.normal.x - v0.normal.x), v0.normal.y + s0 * (v1.normal.y - v0.normal.y), v0.normal.z + s0 * (v1.normal.z - v0.normal.z))); // need to clip more values (texture coordinates)? do it this way:
+        // intersectpoint.value = a.value + s * ( b.value - a.value );
+
+        return v;
+      }
+
+      return _this;
+    }
+
+    return _createClass(DecalGeometry);
+  }(_three.BufferGeometry); // helper
+
+
+  _exports.DecalGeometry = DecalGeometry;
+
+  var DecalVertex = /*#__PURE__*/function () {
+    function DecalVertex(position, normal) {
+      _classCallCheck(this, DecalVertex);
+
+      this.position = position;
+      this.normal = normal;
+    }
+
+    _createClass(DecalVertex, [{
+      key: "clone",
+      value: function clone() {
+        return new this.constructor(this.position.clone(), this.normal.clone());
+      }
+    }]);
+
+    return DecalVertex;
+  }();
+
+  _exports.DecalVertex = DecalVertex;
+});