opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/nodes/materials/SpriteNodeMaterial.js

@@ -0,0 +1,63 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./nodes/SpriteNode.js", "./NodeMaterial.js", "../core/NodeUtils.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./nodes/SpriteNode.js"), require("./NodeMaterial.js"), require("../core/NodeUtils.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.SpriteNode, global.NodeMaterial, global.NodeUtils);
+    global.SpriteNodeMaterial = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _SpriteNode, _NodeMaterial2, _NodeUtils) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.SpriteNodeMaterial = 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 SpriteNodeMaterial = /*#__PURE__*/function (_NodeMaterial) {
+    _inherits(SpriteNodeMaterial, _NodeMaterial);
+
+    var _super = _createSuper(SpriteNodeMaterial);
+
+    function SpriteNodeMaterial() {
+      var _this;
+
+      _classCallCheck(this, SpriteNodeMaterial);
+
+      var node = new _SpriteNode.SpriteNode();
+      _this = _super.call(this, node, node);
+      _this.type = 'SpriteNodeMaterial';
+      return _this;
+    }
+
+    return _createClass(SpriteNodeMaterial);
+  }(_NodeMaterial2.NodeMaterial);
+
+  _exports.SpriteNodeMaterial = SpriteNodeMaterial;
+
+  _NodeUtils.NodeUtils.addShortcuts(SpriteNodeMaterial.prototype, 'fragment', ['color', 'alpha', 'mask', 'position', 'spherical']);
+});

data/lib-opal/js_wrap/three/nodes/materials/StandardNodeMaterial.js

@@ -0,0 +1,63 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./nodes/StandardNode.js", "./NodeMaterial.js", "../core/NodeUtils.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./nodes/StandardNode.js"), require("./NodeMaterial.js"), require("../core/NodeUtils.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.StandardNode, global.NodeMaterial, global.NodeUtils);
+    global.StandardNodeMaterial = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _StandardNode, _NodeMaterial2, _NodeUtils) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.StandardNodeMaterial = 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 StandardNodeMaterial = /*#__PURE__*/function (_NodeMaterial) {
+    _inherits(StandardNodeMaterial, _NodeMaterial);
+
+    var _super = _createSuper(StandardNodeMaterial);
+
+    function StandardNodeMaterial() {
+      var _this;
+
+      _classCallCheck(this, StandardNodeMaterial);
+
+      var node = new _StandardNode.StandardNode();
+      _this = _super.call(this, node, node);
+      _this.type = 'StandardNodeMaterial';
+      return _this;
+    }
+
+    return _createClass(StandardNodeMaterial);
+  }(_NodeMaterial2.NodeMaterial);
+
+  _exports.StandardNodeMaterial = StandardNodeMaterial;
+
+  _NodeUtils.NodeUtils.addShortcuts(StandardNodeMaterial.prototype, 'fragment', ['color', 'alpha', 'roughness', 'metalness', 'reflectivity', 'clearcoat', 'clearcoatRoughness', 'clearcoatNormal', 'normal', 'emissive', 'ambient', 'light', 'shadow', 'ao', 'environment', 'mask', 'position', 'sheenColor']);
+});

data/lib-opal/js_wrap/three/nodes/materials/nodes/BasicNode.js

@@ -0,0 +1,146 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../../core/Node.js", "../../inputs/ColorNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../../core/Node.js"), require("../../inputs/ColorNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Node, global.ColorNode);
+    global.BasicNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _Node2, _ColorNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.BasicNode = 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 BasicNode = /*#__PURE__*/function (_Node) {
+    _inherits(BasicNode, _Node);
+
+    var _super = _createSuper(BasicNode);
+
+    function BasicNode() {
+      var _this;
+
+      _classCallCheck(this, BasicNode);
+
+      _this = _super.call(this);
+      _this.color = new _ColorNode.ColorNode(0xFFFFFF);
+      return _this;
+    }
+
+    _createClass(BasicNode, [{
+      key: "generate",
+      value: function generate(builder) {
+        var code;
+
+        if (builder.isShader('vertex')) {
+          var position = this.position ? this.position.analyzeAndFlow(builder, 'v3', {
+            cache: 'position'
+          }) : undefined;
+          var output = ['#include <beginnormal_vertex>', '#include <morphnormal_vertex>', '#include <skinnormal_vertex>', '#include <defaultnormal_vertex>'];
+          output.push('#include <begin_vertex>');
+
+          if (position) {
+            output.push(position.code, position.result ? 'transformed = ' + position.result + ';' : '');
+          }
+
+          output.push('#include <morphtarget_vertex>', '#include <skinning_vertex>', '#include <project_vertex>', '#include <logdepthbuf_vertex>', '#include <worldpos_vertex>', '#include <clipping_planes_vertex>', '#include <fog_vertex>');
+          code = output.join('\n');
+        } else {
+          // Analyze all nodes to reuse generate codes
+          this.color.analyze(builder, {
+            slot: 'color'
+          });
+          if (this.alpha) this.alpha.analyze(builder);
+          if (this.mask) this.mask.analyze(builder); // Build code
+
+          var color = this.color.flow(builder, 'c', {
+            slot: 'color'
+          });
+          var alpha = this.alpha ? this.alpha.flow(builder, 'f') : undefined;
+          var mask = this.mask ? this.mask.flow(builder, 'b') : undefined;
+          builder.requires.transparent = alpha !== undefined;
+          var _output = [color.code];
+
+          if (mask) {
+            _output.push(mask.code, 'if ( ! ' + mask.result + ' ) discard;');
+          }
+
+          if (alpha) {
+            _output.push(alpha.code, '#ifdef ALPHATEST', ' if ( ' + alpha.result + ' <= ALPHATEST ) discard;', '#endif');
+          }
+
+          if (alpha) {
+            _output.push('gl_FragColor = vec4(' + color.result + ', ' + alpha.result + ' );');
+          } else {
+            _output.push('gl_FragColor = vec4(' + color.result + ', 1.0 );');
+          }
+
+          code = _output.join('\n');
+        }
+
+        return code;
+      }
+    }, {
+      key: "copy",
+      value: function copy(source) {
+        _get(_getPrototypeOf(BasicNode.prototype), "copy", this).call(this, source);
+
+        this.color = source.color;
+        if (source.position) this.position = source.position;
+        if (source.alpha) this.alpha = source.alpha;
+        if (source.mask) this.mask = source.mask;
+        return this;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          data.color = this.color.toJSON(meta).uuid;
+          if (this.position) data.position = this.position.toJSON(meta).uuid;
+          if (this.alpha) data.alpha = this.alpha.toJSON(meta).uuid;
+          if (this.mask) data.mask = this.mask.toJSON(meta).uuid;
+        }
+
+        return data;
+      }
+    }]);
+
+    return BasicNode;
+  }(_Node2.Node);
+
+  _exports.BasicNode = BasicNode;
+  BasicNode.prototype.nodeType = 'Basic';
+});

data/lib-opal/js_wrap/three/nodes/materials/nodes/MeshStandardNode.js

@@ -0,0 +1,133 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./StandardNode.js", "../../inputs/PropertyNode.js", "../../math/OperatorNode.js", "../../utils/SwitchNode.js", "../../misc/NormalMapNode.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./StandardNode.js"), require("../../inputs/PropertyNode.js"), require("../../math/OperatorNode.js"), require("../../utils/SwitchNode.js"), require("../../misc/NormalMapNode.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.StandardNode, global.PropertyNode, global.OperatorNode, global.SwitchNode, global.NormalMapNode);
+    global.MeshStandardNode = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _StandardNode2, _PropertyNode, _OperatorNode, _SwitchNode, _NormalMapNode) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.MeshStandardNode = 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 MeshStandardNode = /*#__PURE__*/function (_StandardNode) {
+    _inherits(MeshStandardNode, _StandardNode);
+
+    var _super = _createSuper(MeshStandardNode);
+
+    function MeshStandardNode() {
+      var _this;
+
+      _classCallCheck(this, MeshStandardNode);
+
+      _this = _super.call(this);
+      _this.properties = {
+        color: new _three.Color(0xffffff),
+        roughness: 0.5,
+        metalness: 0.5,
+        normalScale: new _three.Vector2(1, 1)
+      };
+      _this.inputs = {
+        color: new _PropertyNode.PropertyNode(_this.properties, 'color', 'c'),
+        roughness: new _PropertyNode.PropertyNode(_this.properties, 'roughness', 'f'),
+        metalness: new _PropertyNode.PropertyNode(_this.properties, 'metalness', 'f'),
+        normalScale: new _PropertyNode.PropertyNode(_this.properties, 'normalScale', 'v2')
+      };
+      return _this;
+    }
+
+    _createClass(MeshStandardNode, [{
+      key: "build",
+      value: function build(builder) {
+        var props = this.properties,
+            inputs = this.inputs;
+
+        if (builder.isShader('fragment')) {
+          // slots
+          // * color
+          // * map
+          var color = builder.findNode(props.color, inputs.color),
+              map = builder.resolve(props.map);
+          this.color = map ? new _OperatorNode.OperatorNode(color, map, _OperatorNode.OperatorNode.MUL) : color; // slots
+          // * roughness
+          // * roughnessMap
+
+          var roughness = builder.findNode(props.roughness, inputs.roughness),
+              roughnessMap = builder.resolve(props.roughnessMap);
+          this.roughness = roughnessMap ? new _OperatorNode.OperatorNode(roughness, new _SwitchNode.SwitchNode(roughnessMap, 'g'), _OperatorNode.OperatorNode.MUL) : roughness; // slots
+          // * metalness
+          // * metalnessMap
+
+          var metalness = builder.findNode(props.metalness, inputs.metalness),
+              metalnessMap = builder.resolve(props.metalnessMap);
+          this.metalness = metalnessMap ? new _OperatorNode.OperatorNode(metalness, new _SwitchNode.SwitchNode(metalnessMap, 'b'), _OperatorNode.OperatorNode.MUL) : metalness; // slots
+          // * normalMap
+          // * normalScale
+
+          if (props.normalMap) {
+            this.normal = new _NormalMapNode.NormalMapNode(builder.resolve(props.normalMap));
+            this.normal.scale = builder.findNode(props.normalScale, inputs.normalScale);
+          } else {
+            this.normal = undefined;
+          } // slots
+          // * envMap
+
+
+          this.environment = builder.resolve(props.envMap);
+        } // build code
+
+
+        return _get(_getPrototypeOf(MeshStandardNode.prototype), "build", this).call(this, builder);
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON(meta) {
+        var data = this.getJSONNode(meta);
+
+        if (!data) {
+          data = this.createJSONNode(meta);
+          console.warn('.toJSON not implemented in', this);
+        }
+
+        return data;
+      }
+    }]);
+
+    return MeshStandardNode;
+  }(_StandardNode2.StandardNode);
+
+  _exports.MeshStandardNode = MeshStandardNode;
+  MeshStandardNode.prototype.nodeType = 'MeshStandard';
+});