three-stdlib 2.15.2 → 2.16.1

package/renderers/webgpu/WebGPUAttributes.mjs

@@ -1,69 +0,0 @@
-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/renderers/webgpu/WebGPUBackground.mjs

@@ -1,61 +0,0 @@
-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/renderers/webgpu/WebGPUBinding.mjs

@@ -1,14 +0,0 @@
-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/renderers/webgpu/WebGPUBindings.mjs

@@ -1,155 +0,0 @@
-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/renderers/webgpu/WebGPUComputePipelines.mjs

@@ -1,44 +0,0 @@
-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/renderers/webgpu/WebGPUGeometries.mjs

@@ -1,41 +0,0 @@
-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
-};

package/renderers/webgpu/WebGPUInfo.mjs

@@ -1,46 +0,0 @@
-class WebGPUInfo {
-  constructor() {
-    this.autoReset = true;
-    this.render = {
-      frame: 0,
-      drawCalls: 0,
-      triangles: 0,
-      points: 0,
-      lines: 0
-    };
-    this.memory = {
-      geometries: 0,
-      textures: 0
-    };
-  }
-  update(object, count, instanceCount) {
-    this.render.drawCalls++;
-    if (object.isMesh) {
-      this.render.triangles += instanceCount * (count / 3);
-    } else if (object.isPoints) {
-      this.render.points += instanceCount * count;
-    } else if (object.isLineSegments) {
-      this.render.lines += instanceCount * (count / 2);
-    } else if (object.isLine) {
-      this.render.lines += instanceCount * (count - 1);
-    } else {
-      console.error("THREE.WebGPUInfo: Unknown object type.");
-    }
-  }
-  reset() {
-    this.render.frame++;
-    this.render.drawCalls = 0;
-    this.render.triangles = 0;
-    this.render.points = 0;
-    this.render.lines = 0;
-  }
-  dispose() {
-    this.reset();
-    this.render.frame = 0;
-    this.memory.geometries = 0;
-    this.memory.textures = 0;
-  }
-}
-export {
-  WebGPUInfo as default
-};

package/renderers/webgpu/WebGPUObjects.mjs

@@ -1,25 +0,0 @@
-class WebGPUObjects {
-  constructor(geometries, info) {
-    this.geometries = geometries;
-    this.info = info;
-    this.updateMap = /* @__PURE__ */ new WeakMap();
-  }
-  update(object) {
-    const geometry = object.geometry;
-    const updateMap = this.updateMap;
-    const frame = this.info.render.frame;
-    if (geometry.isBufferGeometry !== true) {
-      throw "THREE.WebGPURenderer: This renderer only supports THREE.BufferGeometry for geometries.";
-    }
-    if (updateMap.get(geometry) !== frame) {
-      this.geometries.update(geometry);
-      updateMap.set(geometry, frame);
-    }
-  }
-  dispose() {
-    this.updateMap = /* @__PURE__ */ new WeakMap();
-  }
-}
-export {
-  WebGPUObjects as default
-};

package/renderers/webgpu/WebGPUProperties.mjs

@@ -1,22 +0,0 @@
-class WebGPUProperties {
-  constructor() {
-    this.properties = /* @__PURE__ */ new WeakMap();
-  }
-  get(object) {
-    let map = this.properties.get(object);
-    if (map === void 0) {
-      map = {};
-      this.properties.set(object, map);
-    }
-    return map;
-  }
-  remove(object) {
-    this.properties.delete(object);
-  }
-  dispose() {
-    this.properties = /* @__PURE__ */ new WeakMap();
-  }
-}
-export {
-  WebGPUProperties as default
-};

package/renderers/webgpu/WebGPURenderLists.mjs

@@ -1,119 +0,0 @@
-function painterSortStable(a, b) {
-  if (a.groupOrder !== b.groupOrder) {
-    return a.groupOrder - b.groupOrder;
-  } else if (a.renderOrder !== b.renderOrder) {
-    return a.renderOrder - b.renderOrder;
-  } else if (a.material.id !== b.material.id) {
-    return a.material.id - b.material.id;
-  } else if (a.z !== b.z) {
-    return a.z - b.z;
-  } else {
-    return a.id - b.id;
-  }
-}
-function reversePainterSortStable(a, b) {
-  if (a.groupOrder !== b.groupOrder) {
-    return a.groupOrder - b.groupOrder;
-  } else if (a.renderOrder !== b.renderOrder) {
-    return a.renderOrder - b.renderOrder;
-  } else if (a.z !== b.z) {
-    return b.z - a.z;
-  } else {
-    return a.id - b.id;
-  }
-}
-class WebGPURenderList {
-  constructor() {
-    this.renderItems = [];
-    this.renderItemsIndex = 0;
-    this.opaque = [];
-    this.transparent = [];
-  }
-  init() {
-    this.renderItemsIndex = 0;
-    this.opaque.length = 0;
-    this.transparent.length = 0;
-  }
-  getNextRenderItem(object, geometry, material, groupOrder, z, group) {
-    let renderItem = this.renderItems[this.renderItemsIndex];
-    if (renderItem === void 0) {
-      renderItem = {
-        id: object.id,
-        object,
-        geometry,
-        material,
-        groupOrder,
-        renderOrder: object.renderOrder,
-        z,
-        group
-      };
-      this.renderItems[this.renderItemsIndex] = renderItem;
-    } else {
-      renderItem.id = object.id;
-      renderItem.object = object;
-      renderItem.geometry = geometry;
-      renderItem.material = material;
-      renderItem.groupOrder = groupOrder;
-      renderItem.renderOrder = object.renderOrder;
-      renderItem.z = z;
-      renderItem.group = group;
-    }
-    this.renderItemsIndex++;
-    return renderItem;
-  }
-  push(object, geometry, material, groupOrder, z, group) {
-    const renderItem = this.getNextRenderItem(object, geometry, material, groupOrder, z, group);
-    (material.transparent === true ? this.transparent : this.opaque).push(renderItem);
-  }
-  unshift(object, geometry, material, groupOrder, z, group) {
-    const renderItem = this.getNextRenderItem(object, geometry, material, groupOrder, z, group);
-    (material.transparent === true ? this.transparent : this.opaque).unshift(renderItem);
-  }
-  sort(customOpaqueSort, customTransparentSort) {
-    if (this.opaque.length > 1)
-      this.opaque.sort(customOpaqueSort || painterSortStable);
-    if (this.transparent.length > 1)
-      this.transparent.sort(customTransparentSort || reversePainterSortStable);
-  }
-  finish() {
-    for (let i = this.renderItemsIndex, il = this.renderItems.length; i < il; i++) {
-      const renderItem = this.renderItems[i];
-      if (renderItem.id === null)
-        break;
-      renderItem.id = null;
-      renderItem.object = null;
-      renderItem.geometry = null;
-      renderItem.material = null;
-      renderItem.program = null;
-      renderItem.group = null;
-    }
-  }
-}
-class WebGPURenderLists {
-  constructor() {
-    this.lists = /* @__PURE__ */ new WeakMap();
-  }
-  get(scene, camera) {
-    const lists = this.lists;
-    const cameras = lists.get(scene);
-    let list;
-    if (cameras === void 0) {
-      list = new WebGPURenderList();
-      lists.set(scene, /* @__PURE__ */ new WeakMap());
-      lists.get(scene).set(camera, list);
-    } else {
-      list = cameras.get(camera);
-      if (list === void 0) {
-        list = new WebGPURenderList();
-        cameras.set(camera, list);
-      }
-    }
-    return list;
-  }
-  dispose() {
-    this.lists = /* @__PURE__ */ new WeakMap();
-  }
-}
-export {
-  WebGPURenderLists as default
-};