three-stdlib 2.22.7 → 2.22.9

package/dist/renderers/webgpu/WebGPUAttributes.mjs

@@ -0,0 +1,69 @@
+class WebGPUAttributes {
+  constructor(device) {
+    this.buffers = /* @__PURE__ */ 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 (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) {
+      data.buffer.destroy();
+      data = this._createBuffer(attribute, usage);
+      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 buffer = this.device.createBuffer({
+      size,
+      usage: usage | GPUBufferUsage.COPY_DST,
+      mappedAtCreation: true
+    });
+    new array.constructor(buffer.getMappedRange()).set(array);
+    buffer.unmap();
+    attribute.onUploadCallback();
+    return {
+      version: attribute.version,
+      buffer,
+      usage
+    };
+  }
+  _writeBuffer(buffer, attribute) {
+    const array = attribute.array;
+    const updateRange = attribute.updateRange;
+    if (updateRange.count === -1) {
+      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;
+    }
+  }
+}
+export {
+  WebGPUAttributes as default
+};

package/dist/renderers/webgpu/WebGPUBackground.js

@@ -0,0 +1,60 @@
+"use strict";
+const constants = require("./constants.js");
+const THREE = require("three");
+let _clearAlpha;
+const _clearColor = new THREE.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) {
+      _clearColor.copy(renderer._clearColor);
+      _clearAlpha = renderer._clearAlpha;
+    } else if (background.isColor === true) {
+      _clearColor.copy(background);
+      _clearAlpha = 1;
+      forceClear = true;
+    } else {
+      console.error("THREE.WebGPURenderer: Unsupported background configuration.", background);
+    }
+    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 = {
+          r: _clearColor.r,
+          g: _clearColor.g,
+          b: _clearColor.b,
+          a: _clearAlpha
+        };
+      } else {
+        colorAttachment.loadValue = constants.GPULoadOp.Load;
+      }
+      if (renderer.autoClearDepth === true) {
+        depthStencilAttachment.depthLoadValue = renderer._clearDepth;
+      } else {
+        depthStencilAttachment.depthLoadValue = constants.GPULoadOp.Load;
+      }
+      if (renderer.autoClearStencil === true) {
+        depthStencilAttachment.stencilLoadValue = renderer._clearDepth;
+      } else {
+        depthStencilAttachment.stencilLoadValue = constants.GPULoadOp.Load;
+      }
+    } else {
+      colorAttachment.loadValue = constants.GPULoadOp.Load;
+      depthStencilAttachment.depthLoadValue = constants.GPULoadOp.Load;
+      depthStencilAttachment.stencilLoadValue = constants.GPULoadOp.Load;
+    }
+    this.forceClear = false;
+  }
+}
+module.exports = WebGPUBackground;

package/dist/renderers/webgpu/WebGPUBackground.mjs

@@ -0,0 +1,61 @@
+import { GPULoadOp } from "./constants.mjs";
+import { Color } from "three";
+let _clearAlpha;
+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) {
+      _clearColor.copy(renderer._clearColor);
+      _clearAlpha = renderer._clearAlpha;
+    } else if (background.isColor === true) {
+      _clearColor.copy(background);
+      _clearAlpha = 1;
+      forceClear = true;
+    } else {
+      console.error("THREE.WebGPURenderer: Unsupported background configuration.", background);
+    }
+    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 = {
+          r: _clearColor.r,
+          g: _clearColor.g,
+          b: _clearColor.b,
+          a: _clearAlpha
+        };
+      } else {
+        colorAttachment.loadValue = GPULoadOp.Load;
+      }
+      if (renderer.autoClearDepth === true) {
+        depthStencilAttachment.depthLoadValue = renderer._clearDepth;
+      } else {
+        depthStencilAttachment.depthLoadValue = GPULoadOp.Load;
+      }
+      if (renderer.autoClearStencil === true) {
+        depthStencilAttachment.stencilLoadValue = renderer._clearDepth;
+      } else {
+        depthStencilAttachment.stencilLoadValue = GPULoadOp.Load;
+      }
+    } else {
+      colorAttachment.loadValue = GPULoadOp.Load;
+      depthStencilAttachment.depthLoadValue = GPULoadOp.Load;
+      depthStencilAttachment.stencilLoadValue = GPULoadOp.Load;
+    }
+    this.forceClear = false;
+  }
+}
+export {
+  WebGPUBackground as default
+};

package/dist/renderers/webgpu/WebGPUBinding.js

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

package/dist/renderers/webgpu/WebGPUBinding.mjs

@@ -0,0 +1,14 @@
+class WebGPUBinding {
+  constructor(name = "") {
+    this.name = name;
+    this.visibility = null;
+    this.type = null;
+    this.isShared = false;
+  }
+  setVisibility(visibility) {
+    this.visibility = visibility;
+  }
+}
+export {
+  WebGPUBinding as default
+};

package/dist/renderers/webgpu/WebGPUBindings.js

@@ -0,0 +1,154 @@
+"use strict";
+class WebGPUBindings {
+  constructor(device, info, properties, textures, pipelines, computePipelines, attributes, nodes) {
+    this.device = device;
+    this.info = info;
+    this.properties = properties;
+    this.textures = textures;
+    this.pipelines = pipelines;
+    this.computePipelines = computePipelines;
+    this.attributes = attributes;
+    this.nodes = nodes;
+    this.uniformsData = /* @__PURE__ */ new WeakMap();
+    this.updateMap = /* @__PURE__ */ new WeakMap();
+  }
+  get(object) {
+    let data = this.uniformsData.get(object);
+    if (data === void 0) {
+      const pipeline = this.pipelines.get(object);
+      const material = object.material;
+      const nodeBuilder = this.nodes.get(material);
+      const bindings = nodeBuilder.getBindings();
+      const bindLayout = pipeline.getBindGroupLayout(0);
+      const bindGroup = this._createBindGroup(bindings, bindLayout);
+      data = {
+        layout: bindLayout,
+        group: bindGroup,
+        bindings
+      };
+      this.uniformsData.set(object, data);
+    }
+    return data;
+  }
+  getForCompute(param) {
+    let data = this.uniformsData.get(param);
+    if (data === void 0) {
+      const pipeline = this.computePipelines.get(param);
+      const bindings = param.bindings !== void 0 ? param.bindings.slice() : [];
+      const bindLayout = pipeline.getBindGroupLayout(0);
+      const bindGroup = this._createBindGroup(bindings, bindLayout);
+      data = {
+        layout: bindLayout,
+        group: bindGroup,
+        bindings
+      };
+      this.uniformsData.set(param, data);
+    }
+    return data;
+  }
+  update(object, camera) {
+    const textures = this.textures;
+    const data = this.get(object);
+    const bindings = data.bindings;
+    const updateMap = this.updateMap;
+    const frame = this.info.render.frame;
+    let needsBindGroupRefresh = false;
+    for (let binding of bindings) {
+      const isShared = binding.isShared;
+      const isUpdated = updateMap.get(binding) === frame;
+      if (isShared && isUpdated)
+        continue;
+      if (binding.isUniformsGroup) {
+        const array = binding.array;
+        const bufferGPU = binding.bufferGPU;
+        binding.onBeforeUpdate(object, camera);
+        const needsBufferWrite = binding.update();
+        if (needsBufferWrite === true) {
+          this.device.queue.writeBuffer(bufferGPU, 0, array, 0);
+        }
+      } else if (binding.isStorageBuffer) {
+        const attribute = binding.attribute;
+        this.attributes.update(attribute, false, binding.usage);
+      } else if (binding.isSampler) {
+        const texture = binding.texture;
+        textures.updateSampler(texture);
+        const samplerGPU = textures.getSampler(texture);
+        if (binding.samplerGPU !== samplerGPU) {
+          binding.samplerGPU = samplerGPU;
+          needsBindGroupRefresh = true;
+        }
+      } else if (binding.isSampledTexture) {
+        const texture = binding.texture;
+        const forceUpdate = textures.updateTexture(texture);
+        const textureGPU = textures.getTextureGPU(texture);
+        if (binding.textureGPU !== textureGPU || forceUpdate === true) {
+          binding.textureGPU = textureGPU;
+          needsBindGroupRefresh = true;
+        }
+      }
+      updateMap.set(binding, frame);
+    }
+    if (needsBindGroupRefresh === true) {
+      data.group = this._createBindGroup(bindings, data.layout);
+    }
+  }
+  dispose() {
+    this.uniformsData = /* @__PURE__ */ new WeakMap();
+    this.updateMap = /* @__PURE__ */ new WeakMap();
+  }
+  _createBindGroup(bindings, layout) {
+    let bindingPoint = 0;
+    const entries = [];
+    for (let binding of bindings) {
+      if (binding.isUniformsGroup) {
+        if (binding.bufferGPU === null) {
+          const byteLength = binding.getByteLength();
+          binding.array = new Float32Array(new ArrayBuffer(byteLength));
+          binding.bufferGPU = this.device.createBuffer({
+            size: byteLength,
+            usage: binding.usage
+          });
+        }
+        entries.push({
+          binding: bindingPoint,
+          resource: { buffer: binding.bufferGPU }
+        });
+      } else if (binding.isStorageBuffer) {
+        if (binding.bufferGPU === null) {
+          const attribute = binding.attribute;
+          this.attributes.update(attribute, false, binding.usage);
+          binding.bufferGPU = this.attributes.get(attribute).buffer;
+        }
+        entries.push({
+          binding: bindingPoint,
+          resource: { buffer: binding.bufferGPU }
+        });
+      } else if (binding.isSampler) {
+        if (binding.samplerGPU === null) {
+          binding.samplerGPU = this.textures.getDefaultSampler();
+        }
+        entries.push({ binding: bindingPoint, resource: binding.samplerGPU });
+      } else if (binding.isSampledTexture) {
+        if (binding.textureGPU === null) {
+          if (binding.isSampledCubeTexture) {
+            binding.textureGPU = this.textures.getDefaultCubeTexture();
+          } else {
+            binding.textureGPU = this.textures.getDefaultTexture();
+          }
+        }
+        entries.push({
+          binding: bindingPoint,
+          resource: binding.textureGPU.createView({
+            dimension: binding.dimension
+          })
+        });
+      }
+      bindingPoint++;
+    }
+    return this.device.createBindGroup({
+      layout,
+      entries
+    });
+  }
+}
+module.exports = WebGPUBindings;

package/dist/renderers/webgpu/WebGPUBindings.mjs

@@ -0,0 +1,155 @@
+class WebGPUBindings {
+  constructor(device, info, properties, textures, pipelines, computePipelines, attributes, nodes) {
+    this.device = device;
+    this.info = info;
+    this.properties = properties;
+    this.textures = textures;
+    this.pipelines = pipelines;
+    this.computePipelines = computePipelines;
+    this.attributes = attributes;
+    this.nodes = nodes;
+    this.uniformsData = /* @__PURE__ */ new WeakMap();
+    this.updateMap = /* @__PURE__ */ new WeakMap();
+  }
+  get(object) {
+    let data = this.uniformsData.get(object);
+    if (data === void 0) {
+      const pipeline = this.pipelines.get(object);
+      const material = object.material;
+      const nodeBuilder = this.nodes.get(material);
+      const bindings = nodeBuilder.getBindings();
+      const bindLayout = pipeline.getBindGroupLayout(0);
+      const bindGroup = this._createBindGroup(bindings, bindLayout);
+      data = {
+        layout: bindLayout,
+        group: bindGroup,
+        bindings
+      };
+      this.uniformsData.set(object, data);
+    }
+    return data;
+  }
+  getForCompute(param) {
+    let data = this.uniformsData.get(param);
+    if (data === void 0) {
+      const pipeline = this.computePipelines.get(param);
+      const bindings = param.bindings !== void 0 ? param.bindings.slice() : [];
+      const bindLayout = pipeline.getBindGroupLayout(0);
+      const bindGroup = this._createBindGroup(bindings, bindLayout);
+      data = {
+        layout: bindLayout,
+        group: bindGroup,
+        bindings
+      };
+      this.uniformsData.set(param, data);
+    }
+    return data;
+  }
+  update(object, camera) {
+    const textures = this.textures;
+    const data = this.get(object);
+    const bindings = data.bindings;
+    const updateMap = this.updateMap;
+    const frame = this.info.render.frame;
+    let needsBindGroupRefresh = false;
+    for (let binding of bindings) {
+      const isShared = binding.isShared;
+      const isUpdated = updateMap.get(binding) === frame;
+      if (isShared && isUpdated)
+        continue;
+      if (binding.isUniformsGroup) {
+        const array = binding.array;
+        const bufferGPU = binding.bufferGPU;
+        binding.onBeforeUpdate(object, camera);
+        const needsBufferWrite = binding.update();
+        if (needsBufferWrite === true) {
+          this.device.queue.writeBuffer(bufferGPU, 0, array, 0);
+        }
+      } else if (binding.isStorageBuffer) {
+        const attribute = binding.attribute;
+        this.attributes.update(attribute, false, binding.usage);
+      } else if (binding.isSampler) {
+        const texture = binding.texture;
+        textures.updateSampler(texture);
+        const samplerGPU = textures.getSampler(texture);
+        if (binding.samplerGPU !== samplerGPU) {
+          binding.samplerGPU = samplerGPU;
+          needsBindGroupRefresh = true;
+        }
+      } else if (binding.isSampledTexture) {
+        const texture = binding.texture;
+        const forceUpdate = textures.updateTexture(texture);
+        const textureGPU = textures.getTextureGPU(texture);
+        if (binding.textureGPU !== textureGPU || forceUpdate === true) {
+          binding.textureGPU = textureGPU;
+          needsBindGroupRefresh = true;
+        }
+      }
+      updateMap.set(binding, frame);
+    }
+    if (needsBindGroupRefresh === true) {
+      data.group = this._createBindGroup(bindings, data.layout);
+    }
+  }
+  dispose() {
+    this.uniformsData = /* @__PURE__ */ new WeakMap();
+    this.updateMap = /* @__PURE__ */ new WeakMap();
+  }
+  _createBindGroup(bindings, layout) {
+    let bindingPoint = 0;
+    const entries = [];
+    for (let binding of bindings) {
+      if (binding.isUniformsGroup) {
+        if (binding.bufferGPU === null) {
+          const byteLength = binding.getByteLength();
+          binding.array = new Float32Array(new ArrayBuffer(byteLength));
+          binding.bufferGPU = this.device.createBuffer({
+            size: byteLength,
+            usage: binding.usage
+          });
+        }
+        entries.push({
+          binding: bindingPoint,
+          resource: { buffer: binding.bufferGPU }
+        });
+      } else if (binding.isStorageBuffer) {
+        if (binding.bufferGPU === null) {
+          const attribute = binding.attribute;
+          this.attributes.update(attribute, false, binding.usage);
+          binding.bufferGPU = this.attributes.get(attribute).buffer;
+        }
+        entries.push({
+          binding: bindingPoint,
+          resource: { buffer: binding.bufferGPU }
+        });
+      } else if (binding.isSampler) {
+        if (binding.samplerGPU === null) {
+          binding.samplerGPU = this.textures.getDefaultSampler();
+        }
+        entries.push({ binding: bindingPoint, resource: binding.samplerGPU });
+      } else if (binding.isSampledTexture) {
+        if (binding.textureGPU === null) {
+          if (binding.isSampledCubeTexture) {
+            binding.textureGPU = this.textures.getDefaultCubeTexture();
+          } else {
+            binding.textureGPU = this.textures.getDefaultTexture();
+          }
+        }
+        entries.push({
+          binding: bindingPoint,
+          resource: binding.textureGPU.createView({
+            dimension: binding.dimension
+          })
+        });
+      }
+      bindingPoint++;
+    }
+    return this.device.createBindGroup({
+      layout,
+      entries
+    });
+  }
+}
+export {
+  WebGPUBindings as default
+};

package/dist/renderers/webgpu/WebGPUComputePipelines.js

@@ -0,0 +1,43 @@
+"use strict";
+class WebGPUComputePipelines {
+  constructor(device, glslang) {
+    this.device = device;
+    this.glslang = glslang;
+    this.pipelines = /* @__PURE__ */ new WeakMap();
+    this.shaderModules = {
+      compute: /* @__PURE__ */ new WeakMap()
+    };
+  }
+  get(param) {
+    let pipeline = this.pipelines.get(param);
+    if (pipeline === void 0) {
+      const device = this.device;
+      const shader = {
+        computeShader: param.shader
+      };
+      const glslang = this.glslang;
+      let moduleCompute = this.shaderModules.compute.get(shader);
+      if (moduleCompute === void 0) {
+        const byteCodeCompute = glslang.compileGLSL(shader.computeShader, "compute");
+        moduleCompute = device.createShaderModule({ code: byteCodeCompute });
+        this.shaderModules.compute.set(shader, moduleCompute);
+      }
+      const computeStage = {
+        module: moduleCompute,
+        entryPoint: "main"
+      };
+      pipeline = device.createComputePipeline({
+        computeStage
+      });
+      this.pipelines.set(param, pipeline);
+    }
+    return pipeline;
+  }
+  dispose() {
+    this.pipelines = /* @__PURE__ */ new WeakMap();
+    this.shaderModules = {
+      compute: /* @__PURE__ */ new WeakMap()
+    };
+  }
+}
+module.exports = WebGPUComputePipelines;

package/dist/renderers/webgpu/WebGPUComputePipelines.mjs

@@ -0,0 +1,44 @@
+class WebGPUComputePipelines {
+  constructor(device, glslang) {
+    this.device = device;
+    this.glslang = glslang;
+    this.pipelines = /* @__PURE__ */ new WeakMap();
+    this.shaderModules = {
+      compute: /* @__PURE__ */ new WeakMap()
+    };
+  }
+  get(param) {
+    let pipeline = this.pipelines.get(param);
+    if (pipeline === void 0) {
+      const device = this.device;
+      const shader = {
+        computeShader: param.shader
+      };
+      const glslang = this.glslang;
+      let moduleCompute = this.shaderModules.compute.get(shader);
+      if (moduleCompute === void 0) {
+        const byteCodeCompute = glslang.compileGLSL(shader.computeShader, "compute");
+        moduleCompute = device.createShaderModule({ code: byteCodeCompute });
+        this.shaderModules.compute.set(shader, moduleCompute);
+      }
+      const computeStage = {
+        module: moduleCompute,
+        entryPoint: "main"
+      };
+      pipeline = device.createComputePipeline({
+        computeStage
+      });
+      this.pipelines.set(param, pipeline);
+    }
+    return pipeline;
+  }
+  dispose() {
+    this.pipelines = /* @__PURE__ */ new WeakMap();
+    this.shaderModules = {
+      compute: /* @__PURE__ */ new WeakMap()
+    };
+  }
+}
+export {
+  WebGPUComputePipelines as default
+};

package/dist/renderers/webgpu/WebGPUGeometries.js

@@ -0,0 +1,40 @@
+"use strict";
+class WebGPUGeometries {
+  constructor(attributes, info) {
+    this.attributes = attributes;
+    this.info = info;
+    this.geometries = /* @__PURE__ */ new WeakMap();
+  }
+  update(geometry) {
+    if (this.geometries.has(geometry) === false) {
+      const disposeCallback = onGeometryDispose.bind(this);
+      this.geometries.set(geometry, disposeCallback);
+      this.info.memory.geometries++;
+      geometry.addEventListener("dispose", disposeCallback);
+    }
+    const geometryAttributes = geometry.attributes;
+    for (let name in geometryAttributes) {
+      this.attributes.update(geometryAttributes[name]);
+    }
+    const index = geometry.index;
+    if (index !== null) {
+      this.attributes.update(index, true);
+    }
+  }
+}
+function onGeometryDispose(event) {
+  const geometry = event.target;
+  const disposeCallback = this.geometries.get(geometry);
+  this.geometries.delete(geometry);
+  this.info.memory.geometries--;
+  geometry.removeEventListener("dispose", disposeCallback);
+  const index = geometry.index;
+  const geometryAttributes = geometry.attributes;
+  if (index !== null) {
+    this.attributes.remove(index);
+  }
+  for (let name in geometryAttributes) {
+    this.attributes.remove(geometryAttributes[name]);
+  }
+}
+module.exports = WebGPUGeometries;

package/dist/renderers/webgpu/WebGPUGeometries.mjs

@@ -0,0 +1,41 @@
+class WebGPUGeometries {
+  constructor(attributes, info) {
+    this.attributes = attributes;
+    this.info = info;
+    this.geometries = /* @__PURE__ */ new WeakMap();
+  }
+  update(geometry) {
+    if (this.geometries.has(geometry) === false) {
+      const disposeCallback = onGeometryDispose.bind(this);
+      this.geometries.set(geometry, disposeCallback);
+      this.info.memory.geometries++;
+      geometry.addEventListener("dispose", disposeCallback);
+    }
+    const geometryAttributes = geometry.attributes;
+    for (let name in geometryAttributes) {
+      this.attributes.update(geometryAttributes[name]);
+    }
+    const index = geometry.index;
+    if (index !== null) {
+      this.attributes.update(index, true);
+    }
+  }
+}
+function onGeometryDispose(event) {
+  const geometry = event.target;
+  const disposeCallback = this.geometries.get(geometry);
+  this.geometries.delete(geometry);
+  this.info.memory.geometries--;
+  geometry.removeEventListener("dispose", disposeCallback);
+  const index = geometry.index;
+  const geometryAttributes = geometry.attributes;
+  if (index !== null) {
+    this.attributes.remove(index);
+  }
+  for (let name in geometryAttributes) {
+    this.attributes.remove(geometryAttributes[name]);
+  }
+}
+export {
+  WebGPUGeometries as default
+};