three-stdlib 2.28.3 → 2.28.5

package/objects/BatchedMesh.d.ts

@@ -4,35 +4,45 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     _vertexCounts: number[];
     _indexStarts: number[];
     _indexCounts: number[];
-    _visibles: boolean[];
-    _alives: boolean[];
+    _reservedRanges: {
+        vertexStart: number;
+        vertexCount: number;
+        indexStart: number;
+        indexCount: number;
+    }[];
+    _visible: boolean[];
+    _active: boolean[];
     _maxGeometryCount: number;
     _maxVertexCount: number;
     _maxIndexCount: number;
     _geometryInitialized: boolean;
     _geometryCount: number;
-    _vertexCount: number;
-    _indexCount: number;
     _matrices: Matrix4[];
-    _matricesArray: Float32Array | null;
     _matricesTexture: DataTexture | null;
-    _matricesTextureSize: number | null;
     _customUniforms: Record<string, IUniform>;
     constructor(maxGeometryCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
     _initMatricesTexture(): void;
     _initShader(): void;
+    _initializeGeometry(reference: BufferGeometry): void;
+    _validateGeometry(geometry: BufferGeometry): void;
     getGeometryCount(): number;
     getVertexCount(): number;
     getIndexCount(): number;
+    addGeometry(geometry: BufferGeometry, vertexCount?: number, indexCount?: number): number;
+    /**
+     * @deprecated use `addGeometry` instead.
+     */
     applyGeometry(geometry: BufferGeometry): number;
+    setGeometryAt(id: number, geometry: BufferGeometry): number;
     deleteGeometry(geometryId: number): this;
-    optimize(): this;
+    optimize(): never;
     setMatrixAt(geometryId: number, matrix: Matrix4): this;
     getMatrixAt(geometryId: number, matrix: Matrix4): Matrix4;
-    setVisibleAt(geometryId: number, visible: boolean): this;
+    setVisibleAt(geometryId: number, value: boolean): this;
     getVisibleAt(geometryId: number): boolean;
-    copy(source: BatchedMesh): this;
-    toJSON(meta: any): any;
+    raycast(): void;
+    copy(): never;
+    toJSON(): never;
     dispose(): this;
 }
 export { BatchedMesh };

package/objects/BatchedMesh.js

@@ -5,27 +5,27 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import { Matrix4, Mesh, BufferGeometry, MathUtils, DataTexture, RGBAFormat, FloatType, BufferAttribute } from "three";
+const ID_ATTR_NAME = "_batch_id_";
 const _identityMatrix = new Matrix4();
 const _zeroScaleMatrix = new Matrix4().set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
 const batchingParsVertex = (
   /* glsl */
   `
 #ifdef BATCHING
-	attribute float id;
+	attribute float ${ID_ATTR_NAME};
 	uniform highp sampler2D batchingTexture;
-	uniform int batchingTextureSize;
 	mat4 getBatchingMatrix( const in float i ) {
-		float j = i * 4.0;
-		float x = mod( j, float( batchingTextureSize ) );
-		float y = floor( j / float( batchingTextureSize ) );
-		float dx = 1.0 / float( batchingTextureSize );
-		float dy = 1.0 / float( batchingTextureSize );
-		y = dy * ( y + 0.5 );
-		vec4 v1 = texture2D( batchingTexture, vec2( dx * ( x + 0.5 ), y ) );
-		vec4 v2 = texture2D( batchingTexture, vec2( dx * ( x + 1.5 ), y ) );
-		vec4 v3 = texture2D( batchingTexture, vec2( dx * ( x + 2.5 ), y ) );
-		vec4 v4 = texture2D( batchingTexture, vec2( dx * ( x + 3.5 ), y ) );
+
+		int size = textureSize( batchingTexture, 0 ).x;
+		int j = int( i ) * 4;
+		int x = j % size;
+		int y = j / size;
+		vec4 v1 = texelFetch( batchingTexture, ivec2( x, y ), 0 );
+		vec4 v2 = texelFetch( batchingTexture, ivec2( x + 1, y ), 0 );
+		vec4 v3 = texelFetch( batchingTexture, ivec2( x + 2, y ), 0 );
+		vec4 v4 = texelFetch( batchingTexture, ivec2( x + 3, y ), 0 );
 		return mat4( v1, v2, v3, v4 );
+
 	}
 #endif
 `
@@ -34,7 +34,7 @@ const batchingbaseVertex = (
   /* glsl */
   `
 #ifdef BATCHING
-	mat4 batchingMatrix = getBatchingMatrix( id );
+	mat4 batchingMatrix = getBatchingMatrix( ${ID_ATTR_NAME} );
 #endif
 `
 );
@@ -57,6 +57,20 @@ const batchingVertex = (
 #endif
 `
 );
+function copyAttributeData(src, target, targetOffset = 0) {
+  const itemSize = target.itemSize;
+  if (src.isInterleavedBufferAttribute || src.array.constructor !== target.array.constructor) {
+    const vertexCount = src.count;
+    for (let i = 0; i < vertexCount; i++) {
+      for (let c = 0; c < itemSize; c++) {
+        target.setComponent(i + targetOffset, c, src.getComponent(i, c));
+      }
+    }
+  } else {
+    target.array.set(src.array, targetOffset * itemSize);
+  }
+  target.needsUpdate = true;
+}
 class BatchedMesh extends Mesh {
   constructor(maxGeometryCount, maxVertexCount, maxIndexCount = maxVertexCount * 2, material) {
     super(new BufferGeometry(), material);
@@ -64,41 +78,34 @@ class BatchedMesh extends Mesh {
     __publicField(this, "_vertexCounts");
     __publicField(this, "_indexStarts");
     __publicField(this, "_indexCounts");
-    __publicField(this, "_visibles");
-    __publicField(this, "_alives");
+    __publicField(this, "_reservedRanges");
+    __publicField(this, "_visible");
+    __publicField(this, "_active");
     __publicField(this, "_maxGeometryCount");
     __publicField(this, "_maxVertexCount");
     __publicField(this, "_maxIndexCount");
     __publicField(this, "_geometryInitialized");
     __publicField(this, "_geometryCount");
-    __publicField(this, "_vertexCount");
-    __publicField(this, "_indexCount");
     __publicField(this, "_matrices");
-    __publicField(this, "_matricesArray");
     __publicField(this, "_matricesTexture");
-    __publicField(this, "_matricesTextureSize");
     __publicField(this, "_customUniforms");
     this._vertexStarts = [];
     this._vertexCounts = [];
     this._indexStarts = [];
     this._indexCounts = [];
-    this._visibles = [];
-    this._alives = [];
+    this._reservedRanges = [];
+    this._visible = [];
+    this._active = [];
     this._maxGeometryCount = maxGeometryCount;
     this._maxVertexCount = maxVertexCount;
     this._maxIndexCount = maxIndexCount;
     this._geometryInitialized = false;
     this._geometryCount = 0;
-    this._vertexCount = 0;
-    this._indexCount = 0;
     this._matrices = [];
-    this._matricesArray = null;
     this._matricesTexture = null;
-    this._matricesTextureSize = null;
     this.frustumCulled = false;
     this._customUniforms = {
-      batchingTexture: { value: null },
-      batchingTextureSize: { value: 0 }
+      batchingTexture: { value: null }
     };
     this._initMatricesTexture();
     this._initShader();
@@ -119,158 +126,295 @@ class BatchedMesh extends Mesh {
     size = Math.max(size, 4);
     const matricesArray = new Float32Array(size * size * 4);
     const matricesTexture = new DataTexture(matricesArray, size, size, RGBAFormat, FloatType);
-    this._matricesArray = matricesArray;
     this._matricesTexture = matricesTexture;
-    this._matricesTextureSize = size;
     this._customUniforms.batchingTexture.value = this._matricesTexture;
-    this._customUniforms.batchingTextureSize.value = this._matricesTextureSize;
   }
   _initShader() {
-    const currentOnBeforeCompile = this.material.onBeforeCompile;
+    const material = this.material;
+    const currentOnBeforeCompile = material.onBeforeCompile;
     const customUniforms = this._customUniforms;
-    this.material.onBeforeCompile = function onBeforeCompile(parameters, renderer) {
-      parameters.vertexShader = parameters.vertexShader.replace("#include <skinning_pars_vertex>", "#include <skinning_pars_vertex>\n" + batchingParsVertex).replace(
-        "#include <skinnormal_vertex>",
-        "#include <skinnormal_vertex>\n" + batchingbaseVertex + batchingnormalVertex
-      ).replace("#include <skinning_vertex>", "#include <skinning_vertex>\n" + batchingVertex);
+    material.onBeforeCompile = function onBeforeCompile(parameters, renderer) {
+      parameters.vertexShader = parameters.vertexShader.replace("#include <skinning_pars_vertex>", "#include <skinning_pars_vertex>\n" + batchingParsVertex).replace("#include <uv_vertex>", "#include <uv_vertex>\n" + batchingbaseVertex).replace("#include <skinnormal_vertex>", "#include <skinnormal_vertex>\n" + batchingnormalVertex).replace("#include <skinning_vertex>", "#include <skinning_vertex>\n" + batchingVertex);
       for (const uniformName in customUniforms) {
         parameters.uniforms[uniformName] = customUniforms[uniformName];
       }
       currentOnBeforeCompile.call(this, parameters, renderer);
     };
-    this.material.defines = this.material.defines || {};
-    this.material.defines.BATCHING = false;
+    material.defines = material.defines || {};
+    material.defines.BATCHING = false;
+  }
+  _initializeGeometry(reference) {
+    const geometry = this.geometry;
+    const maxVertexCount = this._maxVertexCount;
+    const maxGeometryCount = this._maxGeometryCount;
+    const maxIndexCount = this._maxIndexCount;
+    if (this._geometryInitialized === false) {
+      for (const attributeName in reference.attributes) {
+        const srcAttribute = reference.getAttribute(attributeName);
+        const { array, itemSize, normalized } = srcAttribute;
+        const dstArray = new array.constructor(maxVertexCount * itemSize);
+        const dstAttribute = new srcAttribute.constructor(dstArray, itemSize, normalized);
+        dstAttribute.setUsage(srcAttribute.usage);
+        geometry.setAttribute(attributeName, dstAttribute);
+      }
+      if (reference.getIndex() !== null) {
+        const indexArray = maxVertexCount > 65536 ? new Uint32Array(maxIndexCount) : new Uint16Array(maxIndexCount);
+        geometry.setIndex(new BufferAttribute(indexArray, 1));
+      }
+      const idArray = maxGeometryCount > 65536 ? new Uint32Array(maxVertexCount) : new Uint16Array(maxVertexCount);
+      geometry.setAttribute(ID_ATTR_NAME, new BufferAttribute(idArray, 1));
+      this._geometryInitialized = true;
+    }
+  }
+  // Make sure the geometry is compatible with the existing combined geometry atributes
+  _validateGeometry(geometry) {
+    if (geometry.getAttribute(ID_ATTR_NAME)) {
+      throw new Error(`BatchedMesh: Geometry cannot use attribute "${ID_ATTR_NAME}"`);
+    }
+    const batchGeometry = this.geometry;
+    if (Boolean(geometry.getIndex()) !== Boolean(batchGeometry.getIndex())) {
+      throw new Error('BatchedMesh: All geometries must consistently have "index".');
+    }
+    for (const attributeName in batchGeometry.attributes) {
+      if (attributeName === ID_ATTR_NAME) {
+        continue;
+      }
+      if (!geometry.hasAttribute(attributeName)) {
+        throw new Error(
+          `BatchedMesh: Added geometry missing "${attributeName}". All geometries must have consistent attributes.`
+        );
+      }
+      const srcAttribute = geometry.getAttribute(attributeName);
+      const dstAttribute = batchGeometry.getAttribute(attributeName);
+      if (srcAttribute.itemSize !== dstAttribute.itemSize || srcAttribute.normalized !== dstAttribute.normalized) {
+        throw new Error("BatchedMesh: All attributes must have a consistent itemSize and normalized value.");
+      }
+    }
   }
   getGeometryCount() {
     return this._geometryCount;
   }
   getVertexCount() {
-    return this._vertexCount;
+    const reservedRanges = this._reservedRanges;
+    if (reservedRanges.length === 0) {
+      return 0;
+    } else {
+      const finalRange = reservedRanges[reservedRanges.length - 1];
+      return finalRange.vertexStart + finalRange.vertexCount;
+    }
   }
   getIndexCount() {
-    return this._indexCount;
+    const reservedRanges = this._reservedRanges;
+    const geometry = this.geometry;
+    if (geometry.getIndex() === null || reservedRanges.length === 0) {
+      return 0;
+    } else {
+      const finalRange = reservedRanges[reservedRanges.length - 1];
+      return finalRange.indexStart + finalRange.indexCount;
+    }
   }
-  applyGeometry(geometry) {
-    var _a;
-    if (this._geometryCount >= this._maxGeometryCount)
-      ;
-    if (this._geometryInitialized === false) {
-      for (const attributeName in geometry.attributes) {
-        const srcAttribute = geometry.getAttribute(attributeName);
-        const { array, itemSize, normalized } = srcAttribute;
-        const dstArray = new array.constructor(this._maxVertexCount * itemSize);
-        const dstAttribute = new srcAttribute.constructor(dstArray, itemSize, normalized);
-        dstAttribute.setUsage(srcAttribute.usage);
-        this.geometry.setAttribute(attributeName, dstAttribute);
+  addGeometry(geometry, vertexCount = -1, indexCount = -1) {
+    this._initializeGeometry(geometry);
+    this._validateGeometry(geometry);
+    if (this._geometryCount >= this._maxGeometryCount) {
+      throw new Error("BatchedMesh: Maximum geometry count reached.");
+    }
+    const range = {
+      vertexStart: -1,
+      vertexCount: -1,
+      indexStart: -1,
+      indexCount: -1
+    };
+    let lastRange = null;
+    const reservedRanges = this._reservedRanges;
+    if (this._geometryCount !== 0) {
+      lastRange = reservedRanges[reservedRanges.length - 1];
+    }
+    if (vertexCount === -1) {
+      range.vertexCount = geometry.getAttribute("position").count;
+    } else {
+      range.vertexCount = vertexCount;
+    }
+    if (lastRange === null) {
+      range.vertexStart = 0;
+    } else {
+      range.vertexStart = lastRange.vertexStart + lastRange.vertexCount;
+    }
+    if (geometry.getIndex() !== null) {
+      if (indexCount === -1) {
+        range.indexCount = geometry.getIndex().count;
+      } else {
+        range.indexCount = indexCount;
       }
-      if (geometry.getIndex() !== null) {
-        const indexArray = this._maxVertexCount > 65536 ? new Uint32Array(this._maxIndexCount) : new Uint16Array(this._maxIndexCount);
-        this.geometry.setIndex(new BufferAttribute(indexArray, 1));
+      if (lastRange === null) {
+        range.indexStart = 0;
+      } else {
+        range.indexStart = lastRange.indexStart + lastRange.indexCount;
       }
-      const idArray = this._maxGeometryCount > 65536 ? new Uint32Array(this._maxVertexCount) : new Uint16Array(this._maxVertexCount);
-      this.geometry.setAttribute("id", new BufferAttribute(idArray, 1));
-      this._geometryInitialized = true;
     }
-    const hasIndex = this.geometry.getIndex() !== null;
-    const dstIndex = this.geometry.getIndex();
-    const srcIndex = geometry.getIndex();
-    const srcPositionAttribute = geometry.getAttribute("position");
-    this._vertexStarts.push(this._vertexCount);
-    this._vertexCounts.push(srcPositionAttribute.count);
-    if (hasIndex) {
-      this._indexStarts.push(this._indexCount);
-      this._indexCounts.push(srcIndex.count);
+    if (range.indexStart !== -1 && range.indexStart + range.indexCount > this._maxIndexCount || range.vertexStart + range.vertexCount > this._maxVertexCount) {
+      throw new Error("BatchedMesh: Reserved space request exceeds the maximum buffer size.");
+    }
+    const indexCounts = this._indexCounts;
+    const indexStarts = this._indexStarts;
+    const vertexCounts = this._vertexCounts;
+    const vertexStarts = this._vertexStarts;
+    const visible = this._visible;
+    const active = this._active;
+    const matricesTexture = this._matricesTexture;
+    const matrices = this._matrices;
+    const matricesArray = this._matricesTexture.image.data;
+    visible.push(true);
+    active.push(true);
+    const geometryId = this._geometryCount;
+    this._geometryCount++;
+    matrices.push(new Matrix4());
+    _identityMatrix.toArray(matricesArray, geometryId * 16);
+    matricesTexture.needsUpdate = true;
+    reservedRanges.push(range);
+    vertexStarts.push(range.vertexStart);
+    vertexCounts.push(range.vertexCount);
+    if (geometry.getIndex() !== null) {
+      indexStarts.push(range.indexCount);
+      indexCounts.push(range.indexCount);
+    }
+    const idAttribute = this.geometry.getAttribute(ID_ATTR_NAME);
+    for (let i = 0; i < range.vertexCount; i++) {
+      idAttribute.setX(range.vertexStart + i, geometryId);
+    }
+    idAttribute.needsUpdate = true;
+    this.setGeometryAt(geometryId, geometry);
+    return geometryId;
+  }
+  /**
+   * @deprecated use `addGeometry` instead.
+   */
+  applyGeometry(geometry) {
+    return this.addGeometry(geometry);
+  }
+  setGeometryAt(id, geometry) {
+    if (id >= this._geometryCount) {
+      throw new Error("BatchedMesh: Maximum geometry count reached.");
     }
-    this._visibles.push(true);
-    this._alives.push(true);
-    for (const attributeName in geometry.attributes) {
+    this._validateGeometry(geometry);
+    const range = this._reservedRanges[id];
+    if (geometry.getIndex() !== null && geometry.getIndex().count > range.indexCount || geometry.attributes.position.count > range.vertexCount) {
+      throw new Error("BatchedMesh: Reserved space not large enough for provided geometry.");
+    }
+    const batchGeometry = this.geometry;
+    const srcPositionAttribute = geometry.getAttribute("position");
+    const hasIndex = batchGeometry.getIndex() !== null;
+    const dstIndex = batchGeometry.getIndex();
+    const srcIndex = geometry.getIndex();
+    const vertexStart = range.vertexStart;
+    const vertexCount = range.vertexCount;
+    for (const attributeName in batchGeometry.attributes) {
+      if (attributeName === ID_ATTR_NAME) {
+        continue;
+      }
       const srcAttribute = geometry.getAttribute(attributeName);
-      const dstAttribute = this.geometry.getAttribute(attributeName);
-      dstAttribute.array.set(srcAttribute.array, this._vertexCount * dstAttribute.itemSize);
+      const dstAttribute = batchGeometry.getAttribute(attributeName);
+      copyAttributeData(srcAttribute, dstAttribute, vertexStart);
+      const itemSize = srcAttribute.itemSize;
+      for (let i = srcAttribute.count, l = vertexCount; i < l; i++) {
+        const index = vertexStart + i;
+        for (let c = 0; c < itemSize; c++) {
+          dstAttribute.setComponent(index, c, 0);
+        }
+      }
       dstAttribute.needsUpdate = true;
     }
+    this._vertexCounts[id] = srcPositionAttribute.count;
     if (hasIndex) {
+      const indexStart = range.indexStart;
       for (let i = 0; i < srcIndex.count; i++) {
-        dstIndex.setX(this._indexCount + i, this._vertexCount + srcIndex.getX(i));
+        dstIndex.setX(indexStart + i, vertexStart + srcIndex.getX(i));
+      }
+      for (let i = srcIndex.count, l = range.indexCount; i < l; i++) {
+        dstIndex.setX(indexStart + i, vertexStart);
       }
-      this._indexCount += srcIndex.count;
       dstIndex.needsUpdate = true;
+      this._indexCounts[id] = srcIndex.count;
     }
-    const geometryId = this._geometryCount;
-    this._geometryCount++;
-    const idAttribute = this.geometry.getAttribute("id");
-    for (let i = 0; i < srcPositionAttribute.count; i++) {
-      idAttribute.setX(this._vertexCount + i, geometryId);
-    }
-    idAttribute.needsUpdate = true;
-    this._vertexCount += srcPositionAttribute.count;
-    this._matrices.push(new Matrix4());
-    _identityMatrix.toArray((_a = this._matricesArray) != null ? _a : void 0, geometryId * 16);
-    this._matricesTexture.needsUpdate = true;
-    return geometryId;
+    return id;
   }
   deleteGeometry(geometryId) {
-    if (geometryId >= this._alives.length || this._alives[geometryId] === false) {
+    const active = this._active;
+    const matricesTexture = this._matricesTexture;
+    const matricesArray = matricesTexture.image.data;
+    if (geometryId >= active.length || active[geometryId] === false) {
       return this;
     }
-    this._alives[geometryId] = false;
-    _zeroScaleMatrix.toArray(this._matricesArray, geometryId * 16);
-    this._matricesTexture.needsUpdate = true;
+    active[geometryId] = false;
+    _zeroScaleMatrix.toArray(matricesArray, geometryId * 16);
+    matricesTexture.needsUpdate = true;
     return this;
   }
   optimize() {
-    return this;
+    throw new Error("BatchedMesh: Optimize function not implemented.");
   }
   setMatrixAt(geometryId, matrix) {
-    if (geometryId >= this._matrices.length || this._alives[geometryId] === false) {
+    const visible = this._visible;
+    const active = this._active;
+    const matricesTexture = this._matricesTexture;
+    const matrices = this._matrices;
+    const matricesArray = matricesTexture.image.data;
+    if (geometryId >= matrices.length || active[geometryId] === false) {
       return this;
     }
-    this._matrices[geometryId].copy(matrix);
-    if (this._visibles[geometryId] === true) {
-      matrix.toArray(this._matricesArray, geometryId * 16);
-      this._matricesTexture.needsUpdate = true;
+    if (visible[geometryId] === true) {
+      matrix.toArray(matricesArray, geometryId * 16);
+      matricesTexture.needsUpdate = true;
     }
+    matrices[geometryId].copy(matrix);
     return this;
   }
   getMatrixAt(geometryId, matrix) {
-    if (geometryId >= this._matrices.length || this._alives[geometryId] === false) {
+    const matrices = this._matrices;
+    const active = this._active;
+    if (geometryId >= matrices.length || active[geometryId] === false) {
       return matrix;
     }
-    return matrix.copy(this._matrices[geometryId]);
+    return matrix.copy(matrices[geometryId]);
   }
-  setVisibleAt(geometryId, visible) {
-    if (geometryId >= this._visibles.length || this._alives[geometryId] === false) {
+  setVisibleAt(geometryId, value) {
+    const visible = this._visible;
+    const active = this._active;
+    const matricesTexture = this._matricesTexture;
+    const matrices = this._matrices;
+    const matricesArray = matricesTexture.image.data;
+    if (geometryId >= visible.length || active[geometryId] === false || visible[geometryId] === value) {
       return this;
     }
-    if (this._visibles[geometryId] === visible) {
-      return this;
-    }
-    if (visible === true) {
-      this._matrices[geometryId].toArray(this._matricesArray, geometryId * 16);
+    if (value === true) {
+      matrices[geometryId].toArray(matricesArray, geometryId * 16);
     } else {
-      _zeroScaleMatrix.toArray(this._matricesArray, geometryId * 16);
+      _zeroScaleMatrix.toArray(matricesArray, geometryId * 16);
     }
-    this._matricesTexture.needsUpdate = true;
-    this._visibles[geometryId] = visible;
+    matricesTexture.needsUpdate = true;
+    visible[geometryId] = value;
     return this;
   }
   getVisibleAt(geometryId) {
-    if (geometryId >= this._visibles.length || this._alives[geometryId] === false) {
+    const visible = this._visible;
+    const active = this._active;
+    if (geometryId >= visible.length || active[geometryId] === false) {
       return false;
     }
-    return this._visibles[geometryId];
+    return visible[geometryId];
   }
-  copy(source) {
-    super.copy(source);
-    return this;
+  raycast() {
+    console.warn("BatchedMesh: Raycast function not implemented.");
+  }
+  copy() {
+    throw new Error("BatchedMesh: Copy function not implemented.");
   }
-  toJSON(meta) {
-    return super.toJSON(meta);
+  toJSON() {
+    throw new Error("BatchedMesh: toJSON function not implemented.");
   }
   dispose() {
-    var _a;
     this.geometry.dispose();
-    (_a = this._matricesTexture) == null ? void 0 : _a.dispose();
+    this._matricesTexture.dispose();
     this._matricesTexture = null;
     return this;
   }