opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/renderers/webgpu/WebGPUUniform.js

@@ -0,0 +1,237 @@
+(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.WebGPUUniform = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Vector4Uniform = _exports.Vector3Uniform = _exports.Vector2Uniform = _exports.Matrix4Uniform = _exports.Matrix3Uniform = _exports.FloatUniform = _exports.ColorUniform = void 0;
+
+  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); }
+
+  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; }
+
+  var WebGPUUniform = /*#__PURE__*/function () {
+    function WebGPUUniform(name) {
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+      _classCallCheck(this, WebGPUUniform);
+
+      this.name = name;
+      this.value = value;
+      this.boundary = 0; // used to build the uniform buffer according to the STD140 layout
+
+      this.itemSize = 0;
+      this.offset = 0; // this property is set by WebGPUUniformsGroup and marks the start position in the uniform buffer
+    }
+
+    _createClass(WebGPUUniform, [{
+      key: "setValue",
+      value: function setValue(value) {
+        this.value = value;
+      }
+    }, {
+      key: "getValue",
+      value: function getValue() {
+        return this.value;
+      }
+    }]);
+
+    return WebGPUUniform;
+  }();
+
+  var FloatUniform = /*#__PURE__*/function (_WebGPUUniform) {
+    _inherits(FloatUniform, _WebGPUUniform);
+
+    var _super = _createSuper(FloatUniform);
+
+    function FloatUniform(name) {
+      var _this;
+
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+      _classCallCheck(this, FloatUniform);
+
+      _this = _super.call(this, name, value);
+      _this.boundary = 4;
+      _this.itemSize = 1;
+      return _this;
+    }
+
+    return _createClass(FloatUniform);
+  }(WebGPUUniform);
+
+  _exports.FloatUniform = FloatUniform;
+  FloatUniform.prototype.isFloatUniform = true;
+
+  var Vector2Uniform = /*#__PURE__*/function (_WebGPUUniform2) {
+    _inherits(Vector2Uniform, _WebGPUUniform2);
+
+    var _super2 = _createSuper(Vector2Uniform);
+
+    function Vector2Uniform(name) {
+      var _this2;
+
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Vector2();
+
+      _classCallCheck(this, Vector2Uniform);
+
+      _this2 = _super2.call(this, name, value);
+      _this2.boundary = 8;
+      _this2.itemSize = 2;
+      return _this2;
+    }
+
+    return _createClass(Vector2Uniform);
+  }(WebGPUUniform);
+
+  _exports.Vector2Uniform = Vector2Uniform;
+  Vector2Uniform.prototype.isVector2Uniform = true;
+
+  var Vector3Uniform = /*#__PURE__*/function (_WebGPUUniform3) {
+    _inherits(Vector3Uniform, _WebGPUUniform3);
+
+    var _super3 = _createSuper(Vector3Uniform);
+
+    function Vector3Uniform(name) {
+      var _this3;
+
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Vector3();
+
+      _classCallCheck(this, Vector3Uniform);
+
+      _this3 = _super3.call(this, name, value);
+      _this3.boundary = 16;
+      _this3.itemSize = 3;
+      return _this3;
+    }
+
+    return _createClass(Vector3Uniform);
+  }(WebGPUUniform);
+
+  _exports.Vector3Uniform = Vector3Uniform;
+  Vector3Uniform.prototype.isVector3Uniform = true;
+
+  var Vector4Uniform = /*#__PURE__*/function (_WebGPUUniform4) {
+    _inherits(Vector4Uniform, _WebGPUUniform4);
+
+    var _super4 = _createSuper(Vector4Uniform);
+
+    function Vector4Uniform(name) {
+      var _this4;
+
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Vector4();
+
+      _classCallCheck(this, Vector4Uniform);
+
+      _this4 = _super4.call(this, name, value);
+      _this4.boundary = 16;
+      _this4.itemSize = 4;
+      return _this4;
+    }
+
+    return _createClass(Vector4Uniform);
+  }(WebGPUUniform);
+
+  _exports.Vector4Uniform = Vector4Uniform;
+  Vector4Uniform.prototype.isVector4Uniform = true;
+
+  var ColorUniform = /*#__PURE__*/function (_WebGPUUniform5) {
+    _inherits(ColorUniform, _WebGPUUniform5);
+
+    var _super5 = _createSuper(ColorUniform);
+
+    function ColorUniform(name) {
+      var _this5;
+
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Color();
+
+      _classCallCheck(this, ColorUniform);
+
+      _this5 = _super5.call(this, name, value);
+      _this5.boundary = 16;
+      _this5.itemSize = 3;
+      return _this5;
+    }
+
+    return _createClass(ColorUniform);
+  }(WebGPUUniform);
+
+  _exports.ColorUniform = ColorUniform;
+  ColorUniform.prototype.isColorUniform = true;
+
+  var Matrix3Uniform = /*#__PURE__*/function (_WebGPUUniform6) {
+    _inherits(Matrix3Uniform, _WebGPUUniform6);
+
+    var _super6 = _createSuper(Matrix3Uniform);
+
+    function Matrix3Uniform(name) {
+      var _this6;
+
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Matrix3();
+
+      _classCallCheck(this, Matrix3Uniform);
+
+      _this6 = _super6.call(this, name, value);
+      _this6.boundary = 48;
+      _this6.itemSize = 12;
+      return _this6;
+    }
+
+    return _createClass(Matrix3Uniform);
+  }(WebGPUUniform);
+
+  _exports.Matrix3Uniform = Matrix3Uniform;
+  Matrix3Uniform.prototype.isMatrix3Uniform = true;
+
+  var Matrix4Uniform = /*#__PURE__*/function (_WebGPUUniform7) {
+    _inherits(Matrix4Uniform, _WebGPUUniform7);
+
+    var _super7 = _createSuper(Matrix4Uniform);
+
+    function Matrix4Uniform(name) {
+      var _this7;
+
+      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Matrix4();
+
+      _classCallCheck(this, Matrix4Uniform);
+
+      _this7 = _super7.call(this, name, value);
+      _this7.boundary = 64;
+      _this7.itemSize = 16;
+      return _this7;
+    }
+
+    return _createClass(Matrix4Uniform);
+  }(WebGPUUniform);
+
+  _exports.Matrix4Uniform = Matrix4Uniform;
+  Matrix4Uniform.prototype.isMatrix4Uniform = true;
+});

data/lib-opal/js_wrap/three/renderers/webgpu/WebGPUUniformBuffer.js

@@ -0,0 +1,90 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./WebGPUBinding.js", "./WebGPUBufferUtils.js", "./constants.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./WebGPUBinding.js"), require("./WebGPUBufferUtils.js"), require("./constants.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.WebGPUBinding, global.WebGPUBufferUtils, global.constants);
+    global.WebGPUUniformBuffer = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _WebGPUBinding2, _WebGPUBufferUtils, _constants) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _WebGPUBinding2 = _interopRequireDefault(_WebGPUBinding2);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  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 WebGPUUniformBuffer = /*#__PURE__*/function (_WebGPUBinding) {
+    _inherits(WebGPUUniformBuffer, _WebGPUBinding);
+
+    var _super = _createSuper(WebGPUUniformBuffer);
+
+    function WebGPUUniformBuffer(name) {
+      var _this;
+
+      var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+      _classCallCheck(this, WebGPUUniformBuffer);
+
+      _this = _super.call(this, name);
+      _this.bytesPerElement = Float32Array.BYTES_PER_ELEMENT;
+      _this.type = _constants.GPUBindingType.UniformBuffer;
+      _this.visibility = GPUShaderStage.VERTEX;
+      _this.usage = GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST;
+      _this.buffer = buffer;
+      _this.bufferGPU = null; // set by the renderer
+
+      return _this;
+    }
+
+    _createClass(WebGPUUniformBuffer, [{
+      key: "getByteLength",
+      value: function getByteLength() {
+        return (0, _WebGPUBufferUtils.getFloatLength)(this.buffer.byteLength);
+      }
+    }, {
+      key: "getBuffer",
+      value: function getBuffer() {
+        return this.buffer;
+      }
+    }, {
+      key: "update",
+      value: function update() {
+        return true;
+      }
+    }]);
+
+    return WebGPUUniformBuffer;
+  }(_WebGPUBinding2.default);
+
+  WebGPUUniformBuffer.prototype.isUniformBuffer = true;
+  var _default = WebGPUUniformBuffer;
+  _exports.default = _default;
+});

data/lib-opal/js_wrap/three/renderers/webgpu/WebGPUUniformsGroup.js

@@ -0,0 +1,294 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./WebGPUUniformBuffer.js", "./constants.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./WebGPUUniformBuffer.js"), require("./constants.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.WebGPUUniformBuffer, global.constants);
+    global.WebGPUUniformsGroup = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _WebGPUUniformBuffer2, _constants) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = void 0;
+  _WebGPUUniformBuffer2 = _interopRequireDefault(_WebGPUUniformBuffer2);
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+  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 WebGPUUniformsGroup = /*#__PURE__*/function (_WebGPUUniformBuffer) {
+    _inherits(WebGPUUniformsGroup, _WebGPUUniformBuffer);
+
+    var _super = _createSuper(WebGPUUniformsGroup);
+
+    function WebGPUUniformsGroup(name) {
+      var _this;
+
+      _classCallCheck(this, WebGPUUniformsGroup);
+
+      _this = _super.call(this, name); // the order of uniforms in this array must match the order of uniforms in the shader
+
+      _this.uniforms = [];
+      return _this;
+    }
+
+    _createClass(WebGPUUniformsGroup, [{
+      key: "addUniform",
+      value: function addUniform(uniform) {
+        this.uniforms.push(uniform);
+        return this;
+      }
+    }, {
+      key: "removeUniform",
+      value: function removeUniform(uniform) {
+        var index = this.uniforms.indexOf(uniform);
+
+        if (index !== -1) {
+          this.uniforms.splice(index, 1);
+        }
+
+        return this;
+      }
+    }, {
+      key: "getBuffer",
+      value: function getBuffer() {
+        var buffer = this.buffer;
+
+        if (buffer === null) {
+          var byteLength = this.getByteLength();
+          buffer = new Float32Array(new ArrayBuffer(byteLength));
+          this.buffer = buffer;
+        }
+
+        return buffer;
+      }
+    }, {
+      key: "getByteLength",
+      value: function getByteLength() {
+        var offset = 0; // global buffer offset in bytes
+
+        for (var i = 0, l = this.uniforms.length; i < l; i++) {
+          var uniform = this.uniforms[i]; // offset within a single chunk in bytes
+
+          var chunkOffset = offset % _constants.GPUChunkSize;
+          var remainingSizeInChunk = _constants.GPUChunkSize - chunkOffset; // conformance tests
+
+          if (chunkOffset !== 0 && remainingSizeInChunk - uniform.boundary < 0) {
+            // check for chunk overflow
+            offset += _constants.GPUChunkSize - chunkOffset;
+          } else if (chunkOffset % uniform.boundary !== 0) {
+            // check for correct alignment
+            offset += chunkOffset % uniform.boundary;
+          }
+
+          uniform.offset = offset / this.bytesPerElement;
+          offset += uniform.itemSize * this.bytesPerElement;
+        }
+
+        return offset;
+      }
+    }, {
+      key: "update",
+      value: function update() {
+        var updated = false;
+
+        var _iterator = _createForOfIteratorHelper(this.uniforms),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var uniform = _step.value;
+
+            if (this.updateByType(uniform) === true) {
+              updated = true;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+
+        return updated;
+      }
+    }, {
+      key: "updateByType",
+      value: function updateByType(uniform) {
+        if (uniform.isFloatUniform) return this.updateNumber(uniform);
+        if (uniform.isVector2Uniform) return this.updateVector2(uniform);
+        if (uniform.isVector3Uniform) return this.updateVector3(uniform);
+        if (uniform.isVector4Uniform) return this.updateVector4(uniform);
+        if (uniform.isColorUniform) return this.updateColor(uniform);
+        if (uniform.isMatrix3Uniform) return this.updateMatrix3(uniform);
+        if (uniform.isMatrix4Uniform) return this.updateMatrix4(uniform);
+        console.error('THREE.WebGPUUniformsGroup: Unsupported uniform type.', uniform);
+      }
+    }, {
+      key: "updateNumber",
+      value: function updateNumber(uniform) {
+        var updated = false;
+        var a = this.buffer;
+        var v = uniform.getValue();
+        var offset = uniform.offset;
+
+        if (a[offset] !== v) {
+          a[offset] = v;
+          updated = true;
+        }
+
+        return updated;
+      }
+    }, {
+      key: "updateVector2",
+      value: function updateVector2(uniform) {
+        var updated = false;
+        var a = this.buffer;
+        var v = uniform.getValue();
+        var offset = uniform.offset;
+
+        if (a[offset + 0] !== v.x || a[offset + 1] !== v.y) {
+          a[offset + 0] = v.x;
+          a[offset + 1] = v.y;
+          updated = true;
+        }
+
+        return updated;
+      }
+    }, {
+      key: "updateVector3",
+      value: function updateVector3(uniform) {
+        var updated = false;
+        var a = this.buffer;
+        var v = uniform.getValue();
+        var offset = uniform.offset;
+
+        if (a[offset + 0] !== v.x || a[offset + 1] !== v.y || a[offset + 2] !== v.z) {
+          a[offset + 0] = v.x;
+          a[offset + 1] = v.y;
+          a[offset + 2] = v.z;
+          updated = true;
+        }
+
+        return updated;
+      }
+    }, {
+      key: "updateVector4",
+      value: function updateVector4(uniform) {
+        var updated = false;
+        var a = this.buffer;
+        var v = uniform.getValue();
+        var offset = uniform.offset;
+
+        if (a[offset + 0] !== v.x || a[offset + 1] !== v.y || a[offset + 2] !== v.z || a[offset + 4] !== v.w) {
+          a[offset + 0] = v.x;
+          a[offset + 1] = v.y;
+          a[offset + 2] = v.z;
+          a[offset + 3] = v.w;
+          updated = true;
+        }
+
+        return updated;
+      }
+    }, {
+      key: "updateColor",
+      value: function updateColor(uniform) {
+        var updated = false;
+        var a = this.buffer;
+        var c = uniform.getValue();
+        var offset = uniform.offset;
+
+        if (a[offset + 0] !== c.r || a[offset + 1] !== c.g || a[offset + 2] !== c.b) {
+          a[offset + 0] = c.r;
+          a[offset + 1] = c.g;
+          a[offset + 2] = c.b;
+          updated = true;
+        }
+
+        return updated;
+      }
+    }, {
+      key: "updateMatrix3",
+      value: function updateMatrix3(uniform) {
+        var updated = false;
+        var a = this.buffer;
+        var e = uniform.getValue().elements;
+        var offset = uniform.offset;
+
+        if (a[offset + 0] !== e[0] || a[offset + 1] !== e[1] || a[offset + 2] !== e[2] || a[offset + 4] !== e[3] || a[offset + 5] !== e[4] || a[offset + 6] !== e[5] || a[offset + 8] !== e[6] || a[offset + 9] !== e[7] || a[offset + 10] !== e[8]) {
+          a[offset + 0] = e[0];
+          a[offset + 1] = e[1];
+          a[offset + 2] = e[2];
+          a[offset + 4] = e[3];
+          a[offset + 5] = e[4];
+          a[offset + 6] = e[5];
+          a[offset + 8] = e[6];
+          a[offset + 9] = e[7];
+          a[offset + 10] = e[8];
+          updated = true;
+        }
+
+        return updated;
+      }
+    }, {
+      key: "updateMatrix4",
+      value: function updateMatrix4(uniform) {
+        var updated = false;
+        var a = this.buffer;
+        var e = uniform.getValue().elements;
+        var offset = uniform.offset;
+
+        if (arraysEqual(a, e, offset) === false) {
+          a.set(e, offset);
+          updated = true;
+        }
+
+        return updated;
+      }
+    }]);
+
+    return WebGPUUniformsGroup;
+  }(_WebGPUUniformBuffer2.default);
+
+  function arraysEqual(a, b, offset) {
+    for (var i = 0, l = b.length; i < l; i++) {
+      if (a[offset + i] !== b[i]) return false;
+    }
+
+    return true;
+  }
+
+  WebGPUUniformsGroup.prototype.isUniformsGroup = true;
+  var _default = WebGPUUniformsGroup;
+  _exports.default = _default;
+});