three-stdlib 2.16.0 → 2.16.2

package/renderers/nodes/inputs/Matrix3Node.js

@@ -1,11 +1,17 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
-const THREE = require("three");
+import InputNode from '../core/InputNode.js';
+import { Matrix3 } from 'three';
+import '../core/Node.js';
+import '../core/constants.js';
+
 class Matrix3Node extends InputNode {
-  constructor(value = new THREE.Matrix3()) {
-    super("mat3");
+  constructor(value = new Matrix3()) {
+    super('mat3');
     this.value = value;
-    Object.defineProperty(this, "isMatrix3Node", { value: true });
+    Object.defineProperty(this, 'isMatrix3Node', {
+      value: true
+    });
   }
+
 }
-module.exports = Matrix3Node;
+
+export default Matrix3Node;

package/renderers/nodes/inputs/Matrix4Node.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js"),r=require("three");require("../core/Node.cjs.js"),require("../core/constants.cjs.js");module.exports=class extends e{constructor(e=new r.Matrix4){super("mat4"),this.value=e,Object.defineProperty(this,"isMatrix4Node",{value:!0})}};

package/renderers/nodes/inputs/Matrix4Node.js

@@ -1,11 +1,17 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
-const THREE = require("three");
+import InputNode from '../core/InputNode.js';
+import { Matrix4 } from 'three';
+import '../core/Node.js';
+import '../core/constants.js';
+
 class Matrix4Node extends InputNode {
-  constructor(value = new THREE.Matrix4()) {
-    super("mat4");
+  constructor(value = new Matrix4()) {
+    super('mat4');
     this.value = value;
-    Object.defineProperty(this, "isMatrix4Node", { value: true });
+    Object.defineProperty(this, 'isMatrix4Node', {
+      value: true
+    });
   }
+
 }
-module.exports = Matrix4Node;
+
+export default Matrix4Node;

package/renderers/nodes/inputs/TextureNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js"),r=require("../accessors/UVNode.cjs.js");require("../core/Node.cjs.js"),require("../core/constants.cjs.js"),require("../core/AttributeNode.cjs.js");module.exports=class extends e{constructor(e,s=new r){super("texture"),this.value=e,this.uv=s,Object.defineProperty(this,"isTextureNode",{value:!0})}generate(e,r){const s=this.getType(e),t=super.generate(e,s),u=this.uv.build(e,"vec2"),c=e.getTexture(t,u);return e.format(c,s,r)}};

package/renderers/nodes/inputs/TextureNode.js

@@ -1,19 +1,27 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
-const UVNode = require("../accessors/UVNode.js");
+import InputNode from '../core/InputNode.js';
+import UVNode from '../accessors/UVNode.js';
+import '../core/Node.js';
+import '../core/constants.js';
+import '../core/AttributeNode.js';
+
 class TextureNode extends InputNode {
   constructor(value, uv = new UVNode()) {
-    super("texture");
+    super('texture');
     this.value = value;
     this.uv = uv;
-    Object.defineProperty(this, "isTextureNode", { value: true });
+    Object.defineProperty(this, 'isTextureNode', {
+      value: true
+    });
   }
+
   generate(builder, output) {
     const type = this.getType(builder);
     const textureProperty = super.generate(builder, type);
-    const uvSnippet = this.uv.build(builder, "vec2");
+    const uvSnippet = this.uv.build(builder, 'vec2');
     const textureCallSnippet = builder.getTexture(textureProperty, uvSnippet);
     return builder.format(textureCallSnippet, type, output);
   }
+
 }
-module.exports = TextureNode;
+
+export default TextureNode;

package/renderers/nodes/inputs/Vector2Node.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js");require("../core/Node.cjs.js"),require("../core/constants.cjs.js");module.exports=class extends e{constructor(e){super("vec2"),this.value=e,Object.defineProperty(this,"isVector2Node",{value:!0})}};

package/renderers/nodes/inputs/Vector2Node.js

@@ -1,10 +1,16 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
+import InputNode from '../core/InputNode.js';
+import '../core/Node.js';
+import '../core/constants.js';
+
 class Vector2Node extends InputNode {
   constructor(value) {
-    super("vec2");
+    super('vec2');
     this.value = value;
-    Object.defineProperty(this, "isVector2Node", { value: true });
+    Object.defineProperty(this, 'isVector2Node', {
+      value: true
+    });
   }
+
 }
-module.exports = Vector2Node;
+
+export default Vector2Node;

package/renderers/nodes/inputs/Vector3Node.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js"),r=require("three");require("../core/Node.cjs.js"),require("../core/constants.cjs.js");module.exports=class extends e{constructor(e=new r.Vector3){super("vec3"),this.value=e,Object.defineProperty(this,"isVector3Node",{value:!0})}};

package/renderers/nodes/inputs/Vector3Node.js

@@ -1,11 +1,17 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
-const THREE = require("three");
+import InputNode from '../core/InputNode.js';
+import { Vector3 } from 'three';
+import '../core/Node.js';
+import '../core/constants.js';
+
 class Vector3Node extends InputNode {
-  constructor(value = new THREE.Vector3()) {
-    super("vec3");
+  constructor(value = new Vector3()) {
+    super('vec3');
     this.value = value;
-    Object.defineProperty(this, "isVector3Node", { value: true });
+    Object.defineProperty(this, 'isVector3Node', {
+      value: true
+    });
   }
+
 }
-module.exports = Vector3Node;
+
+export default Vector3Node;

package/renderers/nodes/inputs/Vector4Node.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js"),r=require("three");require("../core/Node.cjs.js"),require("../core/constants.cjs.js");module.exports=class extends e{constructor(e=new r.Vector4){super("vec4"),this.value=e,Object.defineProperty(this,"isVector4Node",{value:!0})}};

package/renderers/nodes/inputs/Vector4Node.js

@@ -1,11 +1,17 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
-const THREE = require("three");
+import InputNode from '../core/InputNode.js';
+import { Vector4 } from 'three';
+import '../core/Node.js';
+import '../core/constants.js';
+
 class Vector4Node extends InputNode {
-  constructor(value = new THREE.Vector4()) {
-    super("vec4");
+  constructor(value = new Vector4()) {
+    super('vec4');
     this.value = value;
-    Object.defineProperty(this, "isVector4Node", { value: true });
+    Object.defineProperty(this, 'isVector4Node', {
+      value: true
+    });
   }
+
 }
-module.exports = Vector4Node;
+
+export default Vector4Node;

package/renderers/nodes/math/MathNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("@babel/runtime/helpers/defineProperty"),t=require("../core/Node.cjs.js");function r(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("../core/constants.cjs.js");var s=r(e);class i extends t{constructor(e,t,r=null){super(),this.method=e,this.a=t,this.b=r}getType(e){if(this.method===i.INVERSE_TRANSFORM_DIRETION)return"vec3";{const t=this.a.getType(e);return null!==this.b&&e.getTypeLength(typeB)>e.getTypeLength(t)?typeB:t}}generate(e,t){const r=this.method,s=this.getType(e);let n=null,l=null;return r===i.INVERSE_TRANSFORM_DIRETION?(n=this.a.build(e,"vec3"),l=this.b.build(e,"mat4"),`normalize( ( vec4( ${n}, 0.0 ) * ${l} ).xyz )`):(n=this.a.build(e,s),null!==this.b&&(l=this.b.build(e,s)),null!==l?e.format(`${r}( ${n}, ${l} )`,s,t):e.format(`${r}( ${n} )`,s,t))}}s.default(i,"NORMALIZE","normalize"),s.default(i,"INVERSE_TRANSFORM_DIRETION","inverseTransformDirection"),module.exports=i;

package/renderers/nodes/math/MathNode.js

@@ -1,54 +1,64 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const Node = require("../core/Node.js");
-const _MathNode = class extends Node {
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import Node from '../core/Node.js';
+import '../core/constants.js';
+
+class MathNode extends Node {
   constructor(method, a, b = null) {
     super();
     this.method = method;
     this.a = a;
     this.b = b;
   }
+
   getType(builder) {
     const method = this.method;
-    if (method === _MathNode.INVERSE_TRANSFORM_DIRETION) {
-      return "vec3";
+
+    if (method === MathNode.INVERSE_TRANSFORM_DIRETION) {
+      return 'vec3';
     } else {
       const typeA = this.a.getType(builder);
+
       if (this.b !== null) {
         if (builder.getTypeLength(typeB) > builder.getTypeLength(typeA)) {
+          // anytype x anytype: use the greater length vector
           return typeB;
         }
       }
+
       return typeA;
     }
   }
+
   generate(builder, output) {
     const method = this.method;
     const type = this.getType(builder);
-    let a = null, b = null;
-    if (method === _MathNode.INVERSE_TRANSFORM_DIRETION) {
-      a = this.a.build(builder, "vec3");
-      b = this.b.build(builder, "mat4");
+    let a = null,
+        b = null;
+
+    if (method === MathNode.INVERSE_TRANSFORM_DIRETION) {
+      a = this.a.build(builder, 'vec3');
+      b = this.b.build(builder, 'mat4'); // add in FunctionNode later
+
       return `normalize( ( vec4( ${a}, 0.0 ) * ${b} ).xyz )`;
     } else {
       a = this.a.build(builder, type);
+
       if (this.b !== null) {
         b = this.b.build(builder, type);
       }
     }
+
     if (b !== null) {
       return builder.format(`${method}( ${a}, ${b} )`, type, output);
     } else {
       return builder.format(`${method}( ${a} )`, type, output);
     }
   }
-};
-let MathNode = _MathNode;
-__publicField(MathNode, "NORMALIZE", "normalize");
-__publicField(MathNode, "INVERSE_TRANSFORM_DIRETION", "inverseTransformDirection");
-module.exports = MathNode;
+
+}
+
+_defineProperty(MathNode, "NORMALIZE", 'normalize');
+
+_defineProperty(MathNode, "INVERSE_TRANSFORM_DIRETION", 'inverseTransformDirection');
+
+export default MathNode;

package/renderers/nodes/math/OperatorNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var t=require("../core/Node.cjs.js");require("../core/constants.cjs.js");module.exports=class extends t{constructor(t,e,s){super(),this.op=t,this.a=e,this.b=s}getType(t){const e=this.a.getType(t),s=this.b.getType(t);return t.isMatrix(e)&&t.isVector(s)?s:t.isVector(e)&&t.isMatrix(s)?e:t.getTypeLength(s)>t.getTypeLength(e)?s:e}getVectorFromMatrix(t){return"vec"+t.substr(3)}generate(t,e){let s=this.a.getType(t),r=this.b.getType(t),i=this.getType(t);t.isMatrix(s)&&t.isVector(r)?i=r=this.getVectorFromMatrix(s):t.isVector(s)&&t.isMatrix(r)?i=r=this.getVectorFromMatrix(r):s=r=i;const o=this.a.build(t,s),c=this.b.build(t,r);return t.format(`( ${o} ${this.op} ${c} )`,i,e)}};

package/renderers/nodes/math/OperatorNode.js

@@ -1,5 +1,6 @@
-"use strict";
-const Node = require("../core/Node.js");
+import Node from '../core/Node.js';
+import '../core/constants.js';
+
 class OperatorNode extends Node {
   constructor(op, a, b) {
     super();
@@ -7,35 +8,50 @@ class OperatorNode extends Node {
     this.a = a;
     this.b = b;
   }
+
   getType(builder) {
     const typeA = this.a.getType(builder);
     const typeB = this.b.getType(builder);
+
     if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+      // matrix x vector
       return typeB;
     } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+      // vector x matrix
       return typeA;
     } else if (builder.getTypeLength(typeB) > builder.getTypeLength(typeA)) {
+      // anytype x anytype: use the greater length vector
       return typeB;
     }
+
     return typeA;
   }
+
   getVectorFromMatrix(type) {
-    return "vec" + type.substr(3);
+    return 'vec' + type.substr(3);
   }
+
   generate(builder, output) {
     let typeA = this.a.getType(builder);
     let typeB = this.b.getType(builder);
     let type = this.getType(builder);
+
     if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+      // matrix x vector
       type = typeB = this.getVectorFromMatrix(typeA);
     } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+      // vector x matrix
       type = typeB = this.getVectorFromMatrix(typeB);
     } else {
+      // anytype x anytype
       typeA = typeB = type;
     }
+
     const a = this.a.build(builder, typeA);
     const b = this.b.build(builder, typeB);
     return builder.format(`( ${a} ${this.op} ${b} )`, type, output);
   }
+
 }
-module.exports = OperatorNode;
+
+export default OperatorNode;

package/renderers/nodes/utils/SwitchNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/Node.cjs.js");require("../core/constants.cjs.js");module.exports=class extends e{constructor(e,t="x"){super(),this.node=e,this.components=t}getType(e){return e.getTypeFromLength(this.components.length)}generate(e,t){const s=this.node.getType(e),o=`${this.node.build(e,s)}.${this.components}`;return e.format(o,this.getType(e),t)}};

package/renderers/nodes/utils/SwitchNode.js

@@ -1,19 +1,24 @@
-"use strict";
-const Node = require("../core/Node.js");
+import Node from '../core/Node.js';
+import '../core/constants.js';
+
 class SwitchNode extends Node {
-  constructor(node, components = "x") {
+  constructor(node, components = 'x') {
     super();
     this.node = node;
     this.components = components;
   }
+
   getType(builder) {
     return builder.getTypeFromLength(this.components.length);
   }
+
   generate(builder, output) {
     const nodeType = this.node.getType(builder);
     const nodeSnippet = this.node.build(builder, nodeType);
     const snippet = `${nodeSnippet}.${this.components}`;
     return builder.format(snippet, this.getType(builder), output);
   }
+
 }
-module.exports = SwitchNode;
+
+export default SwitchNode;

package/renderers/nodes/utils/TimerNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../inputs/FloatNode.cjs.js"),s=require("../core/constants.cjs.js");require("../core/InputNode.cjs.js"),require("../core/Node.cjs.js");module.exports=class extends e{constructor(){super(),this.updateType=s.NodeUpdateType.Frame}update(e){this.value=e.time}};

package/renderers/nodes/utils/TimerNode.js

@@ -1,13 +1,18 @@
-"use strict";
-const FloatNode = require("../inputs/FloatNode.js");
-const constants = require("../core/constants.js");
+import FloatNode from '../inputs/FloatNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import '../core/InputNode.js';
+import '../core/Node.js';
+
 class TimerNode extends FloatNode {
   constructor() {
     super();
-    this.updateType = constants.NodeUpdateType.Frame;
+    this.updateType = NodeUpdateType.Frame;
   }
+
   update(frame) {
     this.value = frame.time;
   }
+
 }
-module.exports = TimerNode;
+
+export default TimerNode;

package/renderers/webgpu/WebGPU.cjs.js

@@ -0,0 +1 @@
+"use strict";module.exports=class{static isAvailable(){return void 0!==navigator.gpu}static getErrorMessage(){const e=document.createElement("div");return e.id="webgpumessage",e.style.fontFamily="monospace",e.style.fontSize="13px",e.style.fontWeight="normal",e.style.textAlign="center",e.style.background="#fff",e.style.color="#000",e.style.padding="1.5em",e.style.width="400px",e.style.margin="5em auto 0",e.innerHTML='Your browser does not support <a href="https://gpuweb.github.io/gpuweb/" style="color:#000">WebGPU</a>.',e}};

package/renderers/webgpu/WebGPU.js

@@ -1,23 +1,25 @@
-"use strict";
 class WebGPU {
   static isAvailable() {
-    return navigator.gpu !== void 0;
+    return navigator.gpu !== undefined;
   }
+
   static getErrorMessage() {
     const message = 'Your browser does not support <a href="https://gpuweb.github.io/gpuweb/" style="color:#000">WebGPU</a>.';
-    const element = document.createElement("div");
-    element.id = "webgpumessage";
-    element.style.fontFamily = "monospace";
-    element.style.fontSize = "13px";
-    element.style.fontWeight = "normal";
-    element.style.textAlign = "center";
-    element.style.background = "#fff";
-    element.style.color = "#000";
-    element.style.padding = "1.5em";
-    element.style.width = "400px";
-    element.style.margin = "5em auto 0";
+    const element = document.createElement('div');
+    element.id = 'webgpumessage';
+    element.style.fontFamily = 'monospace';
+    element.style.fontSize = '13px';
+    element.style.fontWeight = 'normal';
+    element.style.textAlign = 'center';
+    element.style.background = '#fff';
+    element.style.color = '#000';
+    element.style.padding = '1.5em';
+    element.style.width = '400px';
+    element.style.margin = '5em auto 0';
     element.innerHTML = message;
     return element;
   }
+
 }
-module.exports = WebGPU;
+
+export default WebGPU;

package/renderers/webgpu/WebGPUAttributes.cjs.js

@@ -0,0 +1 @@
+"use strict";module.exports=class{constructor(e){this.buffers=new WeakMap,this.device=e}get(e){return this.buffers.get(e)}remove(e){const t=this.buffers.get(e);t&&(t.buffer.destroy(),this.buffers.delete(e))}update(e,t=!1,r=null){let s=this.buffers.get(e);void 0===s?(null===r&&(r=!0===t?GPUBufferUsage.INDEX:GPUBufferUsage.VERTEX),s=this._createBuffer(e,r),this.buffers.set(e,s)):r&&r!==s.usage?(s.buffer.destroy(),s=this._createBuffer(e,r),this.buffers.set(e,s)):s.version<e.version&&(this._writeBuffer(s.buffer,e),s.version=e.version)}_createBuffer(e,t){const r=e.array,s=r.byteLength+(4-r.byteLength%4)%4,f=this.device.createBuffer({size:s,usage:t|GPUBufferUsage.COPY_DST,mappedAtCreation:!0});return new r.constructor(f.getMappedRange()).set(r),f.unmap(),e.onUploadCallback(),{version:e.version,buffer:f,usage:t}}_writeBuffer(e,t){const r=t.array,s=t.updateRange;-1===s.count?this.device.queue.writeBuffer(e,0,r,0):(this.device.queue.writeBuffer(e,0,r,s.offset*r.BYTES_PER_ELEMENT,s.count*r.BYTES_PER_ELEMENT),s.count=-1)}};

package/renderers/webgpu/WebGPUAttributes.js

@@ -1,25 +1,30 @@
-"use strict";
 class WebGPUAttributes {
   constructor(device) {
-    this.buffers = /* @__PURE__ */ new WeakMap();
+    this.buffers = new WeakMap();
     this.device = device;
   }
+
   get(attribute) {
     return this.buffers.get(attribute);
   }
+
   remove(attribute) {
     const data = this.buffers.get(attribute);
+
     if (data) {
       data.buffer.destroy();
       this.buffers.delete(attribute);
     }
   }
+
   update(attribute, isIndex = false, usage = null) {
     let data = this.buffers.get(attribute);
-    if (data === void 0) {
+
+    if (data === undefined) {
       if (usage === null) {
         usage = isIndex === true ? GPUBufferUsage.INDEX : GPUBufferUsage.VERTEX;
       }
+
       data = this._createBuffer(attribute, usage);
       this.buffers.set(attribute, data);
     } else if (usage && usage !== data.usage) {
@@ -28,14 +33,17 @@ class WebGPUAttributes {
       this.buffers.set(attribute, data);
     } else if (data.version < attribute.version) {
       this._writeBuffer(data.buffer, attribute);
+
       data.version = attribute.version;
     }
   }
+
   _createBuffer(attribute, usage) {
     const array = attribute.array;
-    const size = array.byteLength + (4 - array.byteLength % 4) % 4;
+    const size = array.byteLength + (4 - array.byteLength % 4) % 4; // ensure 4 byte alignment, see #20441
+
     const buffer = this.device.createBuffer({
-      size,
+      size: size,
       usage: usage | GPUBufferUsage.COPY_DST,
       mappedAtCreation: true
     });
@@ -44,25 +52,24 @@ class WebGPUAttributes {
     attribute.onUploadCallback();
     return {
       version: attribute.version,
-      buffer,
-      usage
+      buffer: buffer,
+      usage: usage
     };
   }
+
   _writeBuffer(buffer, attribute) {
     const array = attribute.array;
     const updateRange = attribute.updateRange;
+
     if (updateRange.count === -1) {
+      // Not using update ranges
       this.device.queue.writeBuffer(buffer, 0, array, 0);
     } else {
-      this.device.queue.writeBuffer(
-        buffer,
-        0,
-        array,
-        updateRange.offset * array.BYTES_PER_ELEMENT,
-        updateRange.count * array.BYTES_PER_ELEMENT
-      );
-      updateRange.count = -1;
+      this.device.queue.writeBuffer(buffer, 0, array, updateRange.offset * array.BYTES_PER_ELEMENT, updateRange.count * array.BYTES_PER_ELEMENT);
+      updateRange.count = -1; // reset range
     }
   }
+
 }
-module.exports = WebGPUAttributes;
+
+export default WebGPUAttributes;

package/renderers/webgpu/WebGPUBackground.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("./constants.cjs.js");let a;const o=new(require("three").Color);module.exports=class{constructor(e){this.renderer=e,this.forceClear=!1}clear(){this.forceClear=!0}update(r){const l=this.renderer,t=!0===r.isScene?r.background:null;let c=this.forceClear;null===t?(o.copy(l._clearColor),a=l._clearAlpha):!0===t.isColor?(o.copy(t),a=1,c=!0):console.error("THREE.WebGPURenderer: Unsupported background configuration.",t);const d=l._renderPassDescriptor,s=d.colorAttachments[0],n=d.depthStencilAttachment;!0===l.autoClear||!0===c?(!0===l.autoClearColor?s.loadValue={r:o.r,g:o.g,b:o.b,a:a}:s.loadValue=e.GPULoadOp.Load,!0===l.autoClearDepth?n.depthLoadValue=l._clearDepth:n.depthLoadValue=e.GPULoadOp.Load,!0===l.autoClearStencil?n.stencilLoadValue=l._clearDepth:n.stencilLoadValue=e.GPULoadOp.Load):(s.loadValue=e.GPULoadOp.Load,n.depthLoadValue=e.GPULoadOp.Load,n.stencilLoadValue=e.GPULoadOp.Load),this.forceClear=!1}};

package/renderers/webgpu/WebGPUBackground.js

@@ -1,33 +1,45 @@
-"use strict";
-const constants = require("./constants.js");
-const THREE = require("three");
+import { GPULoadOp } from './constants.js';
+import { Color } from 'three';
+
 let _clearAlpha;
-const _clearColor = new THREE.Color();
+
+const _clearColor = new Color();
+
 class WebGPUBackground {
   constructor(renderer) {
     this.renderer = renderer;
     this.forceClear = false;
   }
+
   clear() {
     this.forceClear = true;
   }
+
   update(scene) {
     const renderer = this.renderer;
     const background = scene.isScene === true ? scene.background : null;
     let forceClear = this.forceClear;
+
     if (background === null) {
+      // no background settings, use clear color configuration from the renderer
       _clearColor.copy(renderer._clearColor);
+
       _clearAlpha = renderer._clearAlpha;
     } else if (background.isColor === true) {
+      // background is an opaque color
       _clearColor.copy(background);
+
       _clearAlpha = 1;
       forceClear = true;
     } else {
-      console.error("THREE.WebGPURenderer: Unsupported background configuration.", background);
-    }
+      console.error('THREE.WebGPURenderer: Unsupported background configuration.', background);
+    } // configure render pass descriptor
+
+
     const renderPassDescriptor = renderer._renderPassDescriptor;
     const colorAttachment = renderPassDescriptor.colorAttachments[0];
     const depthStencilAttachment = renderPassDescriptor.depthStencilAttachment;
+
     if (renderer.autoClear === true || forceClear === true) {
       if (renderer.autoClearColor === true) {
         colorAttachment.loadValue = {
@@ -37,24 +49,29 @@ class WebGPUBackground {
           a: _clearAlpha
         };
       } else {
-        colorAttachment.loadValue = constants.GPULoadOp.Load;
+        colorAttachment.loadValue = GPULoadOp.Load;
       }
+
       if (renderer.autoClearDepth === true) {
         depthStencilAttachment.depthLoadValue = renderer._clearDepth;
       } else {
-        depthStencilAttachment.depthLoadValue = constants.GPULoadOp.Load;
+        depthStencilAttachment.depthLoadValue = GPULoadOp.Load;
       }
+
       if (renderer.autoClearStencil === true) {
         depthStencilAttachment.stencilLoadValue = renderer._clearDepth;
       } else {
-        depthStencilAttachment.stencilLoadValue = constants.GPULoadOp.Load;
+        depthStencilAttachment.stencilLoadValue = GPULoadOp.Load;
       }
     } else {
-      colorAttachment.loadValue = constants.GPULoadOp.Load;
-      depthStencilAttachment.depthLoadValue = constants.GPULoadOp.Load;
-      depthStencilAttachment.stencilLoadValue = constants.GPULoadOp.Load;
+      colorAttachment.loadValue = GPULoadOp.Load;
+      depthStencilAttachment.depthLoadValue = GPULoadOp.Load;
+      depthStencilAttachment.stencilLoadValue = GPULoadOp.Load;
     }
+
     this.forceClear = false;
   }
+
 }
-module.exports = WebGPUBackground;
+
+export default WebGPUBackground;

package/renderers/webgpu/WebGPUBinding.cjs.js

@@ -0,0 +1 @@
+"use strict";module.exports=class{constructor(i=""){this.name=i,this.visibility=null,this.type=null,this.isShared=!1}setVisibility(i){this.visibility=i}};