r3f-peridot 0.1.0

package/dist/index.mjs

@@ -0,0 +1,789 @@
+import { forwardRef, useRef, useEffect, useImperativeHandle } from 'react';
+import { useThree, useFrame } from '@react-three/fiber';
+import * as THREE2 from 'three';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
+import { FXAAShader } from 'three/examples/jsm/shaders/FXAAShader.js';
+import { Pass, FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+
+// src/components/OutlineEffect.tsx
+var FindSurfaces = class {
+  constructor() {
+    this.surfaceId = 0;
+    this.surfaceId = 0;
+  }
+  /*
+   * Returns the surface Ids as a Float32Array that can be inserted as a vertex attribute
+   */
+  getSurfaceIdAttribute(mesh) {
+    const bufferGeometry = mesh.geometry;
+    const numVertices = bufferGeometry.attributes.position.count;
+    const vertexIdToSurfaceId = this._generateSurfaceIds(mesh);
+    const colors = [];
+    for (let i = 0; i < numVertices; i++) {
+      const vertexId = i;
+      const surfaceId = vertexIdToSurfaceId[vertexId];
+      colors.push(surfaceId, 0, 0, 1);
+    }
+    const colorsTypedArray = new Float32Array(colors);
+    return colorsTypedArray;
+  }
+  /*
+   * Returns a `vertexIdToSurfaceId` map
+   * given a vertex, returns the surfaceId
+   */
+  _generateSurfaceIds(mesh) {
+    const bufferGeometry = mesh.geometry;
+    if (!bufferGeometry.index) {
+      const indices = [];
+      const numVertices = bufferGeometry.attributes.position.count;
+      for (let i = 0; i < numVertices; i++) {
+        indices.push(i);
+      }
+      bufferGeometry.setIndex(indices);
+    }
+    const numIndices = bufferGeometry.index.count;
+    const indexBuffer = bufferGeometry.index.array;
+    const vertexMap = {};
+    for (let i = 0; i < numIndices; i += 3) {
+      const i1 = indexBuffer[i + 0];
+      const i2 = indexBuffer[i + 1];
+      const i3 = indexBuffer[i + 2];
+      add(i1, i2);
+      add(i1, i3);
+      add(i2, i3);
+    }
+    function add(a, b) {
+      if (vertexMap[a] == void 0) vertexMap[a] = [];
+      if (vertexMap[b] == void 0) vertexMap[b] = [];
+      if (vertexMap[a].indexOf(b) == -1) vertexMap[a].push(b);
+      if (vertexMap[b].indexOf(a) == -1) vertexMap[b].push(a);
+    }
+    const frontierNodes = Object.keys(vertexMap).map((v) => Number(v));
+    const exploredNodes = {};
+    const vertexIdToSurfaceId = {};
+    while (frontierNodes.length > 0) {
+      const node = frontierNodes.pop();
+      if (exploredNodes[node]) continue;
+      const surfaceVertices = getNeighborsNonRecursive(node);
+      for (const v of surfaceVertices) {
+        exploredNodes[v] = true;
+        vertexIdToSurfaceId[v] = this.surfaceId;
+      }
+      this.surfaceId += 1;
+    }
+    function getNeighborsNonRecursive(node) {
+      const frontier = [node];
+      const explored = {};
+      const result = [];
+      while (frontier.length > 0) {
+        const currentNode = frontier.pop();
+        if (explored[currentNode]) continue;
+        const neighbors = vertexMap[currentNode];
+        result.push(currentNode);
+        explored[currentNode] = true;
+        for (const n of neighbors) {
+          if (!explored[n]) {
+            frontier.push(n);
+          }
+        }
+      }
+      return result;
+    }
+    return vertexIdToSurfaceId;
+  }
+};
+var FindSurfaces_default = FindSurfaces;
+function getSurfaceIdMaterial() {
+  return new THREE2.ShaderMaterial({
+    uniforms: {
+      maxSurfaceId: { value: 1 }
+    },
+    vertexShader: getVertexShader(),
+    fragmentShader: getFragmentShader(),
+    vertexColors: true
+  });
+}
+function getVertexShader() {
+  return `
+  varying vec2 v_uv;
+  varying vec4 vColor;
+
+  void main() {
+     v_uv = uv;
+     #ifdef USE_COLOR_ALPHA
+       vColor = color;
+     #else
+       vColor = vec4(color, 1.0);
+     #endif
+
+     gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+  `;
+}
+function getFragmentShader() {
+  return `
+      varying vec2 v_uv;
+      varying vec4 vColor;
+      uniform float maxSurfaceId;
+
+      void main() {
+        // Normalize the surfaceId when writing to texture
+        // Surface ID needs rounding as precision can be lost in perspective correct interpolation 
+        // - see https://github.com/OmarShehata/webgl-outlines/issues/9 for other solutions eg. flat interpolation.
+        float surfaceId = round(vColor.r) / maxSurfaceId;
+        gl_FragColor = vec4(surfaceId, 0.0, 0.0, 1.0);
+      }
+  `;
+}
+function getDebugSurfaceIdMaterial() {
+  return new THREE2.ShaderMaterial({
+    uniforms: {},
+    vertexShader: getVertexShader(),
+    fragmentShader: `
+      varying vec2 v_uv;
+      varying vec4 vColor;
+
+      void main() {      
+          int surfaceId = int(round(vColor.r) * 100.0);
+          float R = float(surfaceId % 255) / 255.0;
+          float G = float((surfaceId + 50) % 255) / 255.0;
+          float B = float((surfaceId * 20) % 255) / 255.0;
+
+          gl_FragColor = vec4(R, G, B, 1.0);
+      }
+    `,
+    vertexColors: true
+  });
+}
+
+// src/utils/CustomOutlinePass.ts
+var CustomOutlinePass = class extends Pass {
+  constructor(resolution, scene, camera) {
+    super();
+    this.renderScene = scene;
+    this.renderCamera = camera;
+    this.resolution = new THREE2.Vector2(resolution.x, resolution.y);
+    this.fsQuad = new FullScreenQuad(null);
+    this.fsQuad.material = this.createOutlinePostProcessMaterial();
+    const surfaceBuffer = new THREE2.WebGLRenderTarget(this.resolution.x, this.resolution.y);
+    surfaceBuffer.texture.format = THREE2.RGBAFormat;
+    surfaceBuffer.texture.type = THREE2.HalfFloatType;
+    surfaceBuffer.texture.minFilter = THREE2.NearestFilter;
+    surfaceBuffer.texture.magFilter = THREE2.NearestFilter;
+    surfaceBuffer.texture.generateMipmaps = false;
+    surfaceBuffer.stencilBuffer = false;
+    this.surfaceBuffer = surfaceBuffer;
+    this.normalOverrideMaterial = new THREE2.MeshNormalMaterial();
+    this.surfaceIdOverrideMaterial = getSurfaceIdMaterial();
+    this.surfaceIdDebugOverrideMaterial = getDebugSurfaceIdMaterial();
+  }
+  dispose() {
+    this.surfaceBuffer.dispose();
+    this.fsQuad.dispose();
+  }
+  updateMaxSurfaceId(maxSurfaceId) {
+    this.surfaceIdOverrideMaterial.uniforms.maxSurfaceId.value = maxSurfaceId;
+  }
+  setSize(width, height) {
+    this.surfaceBuffer.setSize(width, height);
+    this.resolution.set(width, height);
+    const screenSize = new THREE2.Vector4(
+      this.resolution.x,
+      this.resolution.y,
+      1 / this.resolution.x,
+      1 / this.resolution.y
+    );
+    const material = this.fsQuad.material;
+    material.uniforms.screenSize.value.set(screenSize.x, screenSize.y, screenSize.z, screenSize.w);
+  }
+  getDebugVisualizeValue() {
+    return this.fsQuad.material.uniforms.debugVisualize.value;
+  }
+  isUsingSurfaceIds() {
+    const debugVisualize = this.getDebugVisualizeValue();
+    return debugVisualize == 0 || // Main outlines v2 mode
+    debugVisualize == 5 || // Render just surfaceID debug buffer
+    debugVisualize == 6;
+  }
+  render(renderer, writeBuffer, readBuffer) {
+    const debugVisualize = this.getDebugVisualizeValue();
+    const isUsingSurfaceIds = this.isUsingSurfaceIds();
+    const depthBufferValue = writeBuffer.depthBuffer;
+    writeBuffer.depthBuffer = false;
+    renderer.setRenderTarget(this.surfaceBuffer);
+    const overrideMaterialValue = this.renderScene.overrideMaterial;
+    if (isUsingSurfaceIds) {
+      if (debugVisualize == 5) {
+        this.renderScene.overrideMaterial = this.surfaceIdDebugOverrideMaterial;
+      } else {
+        this.renderScene.overrideMaterial = this.surfaceIdOverrideMaterial;
+      }
+    } else {
+      this.renderScene.overrideMaterial = this.normalOverrideMaterial;
+    }
+    renderer.render(this.renderScene, this.renderCamera);
+    this.renderScene.overrideMaterial = overrideMaterialValue;
+    const material = this.fsQuad.material;
+    material.uniforms["depthBuffer"].value = readBuffer.depthTexture;
+    material.uniforms["surfaceBuffer"].value = this.surfaceBuffer.texture;
+    material.uniforms["sceneColorBuffer"].value = readBuffer.texture;
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null);
+      this.fsQuad.render(renderer);
+    } else {
+      renderer.setRenderTarget(writeBuffer);
+      this.fsQuad.render(renderer);
+    }
+    writeBuffer.depthBuffer = depthBufferValue;
+  }
+  get vertexShader() {
+    return `
+			varying vec2 vUv;
+			void main() {
+				vUv = uv;
+				gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+			}
+			`;
+  }
+  get fragmentShader() {
+    return `
+			#include <packing>
+			// The above include imports "perspectiveDepthToViewZ"
+			// and other GLSL functions from ThreeJS we need for reading depth.
+			uniform sampler2D sceneColorBuffer;
+			uniform sampler2D depthBuffer;
+			uniform sampler2D surfaceBuffer;
+			uniform float cameraNear;
+			uniform float cameraFar;
+			uniform vec4 screenSize;
+			uniform vec3 outlineColor;
+			uniform vec4 multiplierParameters;
+			uniform int debugVisualize;
+
+			varying vec2 vUv;
+
+			// Helper functions for reading from depth buffer.
+			float readDepth (sampler2D depthSampler, vec2 coord) {
+				float fragCoordZ = texture2D(depthSampler, coord).x;
+				float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
+				return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
+			}
+			float getLinearDepth(vec3 pos) {
+				return -(viewMatrix * vec4(pos, 1.0)).z;
+			}
+
+			float getLinearScreenDepth(sampler2D map) {
+					vec2 uv = gl_FragCoord.xy * screenSize.zw;
+					return readDepth(map,uv);
+			}
+			// Helper functions for reading normals and depth of neighboring pixels.
+			float getPixelDepth(int x, int y) {
+				// screenSize.zw is pixel size 
+				// vUv is current position
+				return readDepth(depthBuffer, vUv + screenSize.zw * vec2(x, y));
+			}
+			// "surface value" is either the normal or the "surfaceID"
+			vec3 getSurfaceValue(int x, int y) {
+				vec3 val = texture2D(surfaceBuffer, vUv + screenSize.zw * vec2(x, y)).rgb;
+				return val;
+			}
+
+			float saturateValue(float num) {
+				return clamp(num, 0.0, 1.0);
+			}
+
+			float getSufaceIdDiff(vec3 surfaceValue) {
+				float surfaceIdDiff = 0.0;
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(1, 0));
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(0, 1));
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(0, 1));
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(0, -1));
+
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(1, 1));
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(1, -1));
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(-1, 1));
+				surfaceIdDiff += distance(surfaceValue, getSurfaceValue(-1, -1));
+				return surfaceIdDiff;
+			}
+
+			void main() {
+				vec4 sceneColor = texture2D(sceneColorBuffer, vUv);
+				float depth = getPixelDepth(0, 0);
+				// "surfaceValue" is either the normal or the surfaceId
+				vec3 surfaceValue = getSurfaceValue(0, 0);
+
+				// Get the difference between depth of neighboring pixels and current.
+				float depthDiff = 0.0;
+				depthDiff += abs(depth - getPixelDepth(1, 0));
+				depthDiff += abs(depth - getPixelDepth(-1, 0));
+				depthDiff += abs(depth - getPixelDepth(0, 1));
+				depthDiff += abs(depth - getPixelDepth(0, -1));
+
+				// Get the difference between surface values of neighboring pixels
+				// and current
+				float surfaceValueDiff = getSufaceIdDiff(surfaceValue);
+				
+				// Apply multiplier & bias to each 
+				float depthBias = multiplierParameters.x;
+				float depthMultiplier = multiplierParameters.y;
+				float normalBias = multiplierParameters.z;
+				float normalMultiplier = multiplierParameters.w;
+
+				depthDiff = depthDiff * depthMultiplier;
+				depthDiff = saturateValue(depthDiff);
+				depthDiff = pow(depthDiff, depthBias);
+
+				if (debugVisualize != 0 && debugVisualize != 6) {
+					// Apply these params when using
+					// normals instead of surfaceIds
+					surfaceValueDiff = surfaceValueDiff * normalMultiplier;
+					surfaceValueDiff = saturateValue(surfaceValueDiff);
+					surfaceValueDiff = pow(surfaceValueDiff, normalBias);
+				} else {
+					if (surfaceValueDiff != 0.0) surfaceValueDiff = 1.0;
+				}
+
+				float outline = saturateValue(surfaceValueDiff + depthDiff);
+			
+				// Combine outline with scene color.
+				vec4 outlineColor = vec4(outlineColor, 1.0);
+				gl_FragColor = vec4(mix(sceneColor, outlineColor, outline));
+
+				//// For debug visualization of the different inputs to this shader.
+				if (debugVisualize == 2) {
+					gl_FragColor = sceneColor;
+				}
+				if (debugVisualize == 3) {
+					gl_FragColor = vec4(vec3(depth), 1.0);
+				}
+				if (debugVisualize == 4 || debugVisualize == 5) {
+					// 4 visualizes the normal buffer
+					// 5 visualizes the surfaceID buffer 
+					// Either way they are the same buffer, we change 
+					// what we render into it
+					gl_FragColor = vec4(surfaceValue, 1.0);
+				}
+				if (debugVisualize == 6 || debugVisualize == 7) {
+					// Outlines only
+					gl_FragColor = vec4(vec3(outline * outlineColor), 1.0);
+				}				
+			}
+			`;
+  }
+  createOutlinePostProcessMaterial() {
+    const camera = this.renderCamera;
+    return new THREE2.ShaderMaterial({
+      uniforms: {
+        debugVisualize: { value: 0 },
+        sceneColorBuffer: { value: null },
+        depthBuffer: { value: null },
+        surfaceBuffer: { value: null },
+        outlineColor: { value: new THREE2.Color(16777215) },
+        //4 scalar values packed in one uniform: depth multiplier, depth bias, and same for normals.
+        multiplierParameters: {
+          value: new THREE2.Vector4(0.9, 20, 1, 1)
+        },
+        cameraNear: { value: camera.near },
+        cameraFar: { value: camera.far },
+        screenSize: {
+          value: new THREE2.Vector4(
+            this.resolution.x,
+            this.resolution.y,
+            1 / this.resolution.x,
+            1 / this.resolution.y
+          )
+        }
+      },
+      vertexShader: this.vertexShader,
+      fragmentShader: this.fragmentShader
+    });
+  }
+};
+
+// src/components/OutlineEffect.tsx
+var OutlineEffect = forwardRef(
+  ({
+    enabled = true,
+    outlineColor = "#ffffff",
+    depthBias = 0.9,
+    depthMultiplier = 20,
+    normalBias = 1,
+    normalMultiplier = 1,
+    debugVisualize = 0
+  }, ref) => {
+    const { gl, scene, camera, size, invalidate } = useThree();
+    const composerRef = useRef(null);
+    const outlinePassRef = useRef(null);
+    const fxaaPassRef = useRef(null);
+    const surfaceIdsComputedRef = useRef(false);
+    useEffect(() => {
+      if (!enabled) {
+        if (composerRef.current) {
+          composerRef.current.dispose();
+          composerRef.current = null;
+        }
+        return;
+      }
+      const width = Math.max(1, size.width * gl.getPixelRatio());
+      const height = Math.max(1, size.height * gl.getPixelRatio());
+      const depthTexture = new THREE2.DepthTexture(width, height);
+      const renderTarget = new THREE2.WebGLRenderTarget(width, height, {
+        depthTexture,
+        depthBuffer: true
+      });
+      const composer = new EffectComposer(gl, renderTarget);
+      composerRef.current = composer;
+      const renderPass = new RenderPass(scene, camera);
+      composer.addPass(renderPass);
+      const customOutline = new CustomOutlinePass(new THREE2.Vector2(width, height), scene, camera);
+      customOutline.renderToScreen = true;
+      outlinePassRef.current = customOutline;
+      composer.addPass(customOutline);
+      const effectFXAA = new ShaderPass(FXAAShader);
+      effectFXAA.uniforms["resolution"].value.set(1 / width, 1 / height);
+      effectFXAA.renderToScreen = true;
+      customOutline.renderToScreen = false;
+      fxaaPassRef.current = effectFXAA;
+      composer.addPass(effectFXAA);
+      return () => {
+        composer.dispose();
+        renderTarget.dispose();
+        depthTexture.dispose();
+      };
+    }, [enabled, scene, camera, gl, size.width, size.height, invalidate]);
+    useEffect(() => {
+      if (!enabled) return;
+      const isUsingSurfaceIds = debugVisualize === 0 || debugVisualize === 5 || debugVisualize === 6;
+      if (isUsingSurfaceIds && !surfaceIdsComputedRef.current) {
+        const findSurfaces = new FindSurfaces_default();
+        let maxSurfaceId = 0;
+        scene.traverse((object) => {
+          if (object instanceof THREE2.Mesh && object.geometry) {
+            try {
+              const geometry = object.geometry;
+              const surfaceIdAttribute = findSurfaces.getSurfaceIdAttribute(object);
+              geometry.setAttribute("color", new THREE2.BufferAttribute(surfaceIdAttribute, 4));
+              maxSurfaceId = Math.max(maxSurfaceId, findSurfaces.surfaceId);
+            } catch (error) {
+              console.warn("Failed to compute surface IDs for mesh:", error);
+            }
+          }
+        });
+        if (outlinePassRef.current && maxSurfaceId > 0) {
+          outlinePassRef.current.updateMaxSurfaceId(maxSurfaceId + 1);
+        }
+        surfaceIdsComputedRef.current = true;
+      } else if (!isUsingSurfaceIds && surfaceIdsComputedRef.current) {
+        scene.traverse((object) => {
+          if (object instanceof THREE2.Mesh && object.geometry) {
+            object.geometry.deleteAttribute("color");
+          }
+        });
+        surfaceIdsComputedRef.current = false;
+      }
+    }, [enabled, scene, debugVisualize]);
+    useFrame(() => {
+      if (!enabled || !outlinePassRef.current || !composerRef.current) {
+        return;
+      }
+      const outlinePass = outlinePassRef.current;
+      const material = outlinePass.fsQuad.material;
+      const uniforms = material.uniforms;
+      if (typeof outlineColor === "string") {
+        uniforms.outlineColor.value.set(outlineColor);
+      } else {
+        uniforms.outlineColor.value.copy(outlineColor);
+      }
+      uniforms.multiplierParameters.value.set(
+        depthBias,
+        depthMultiplier,
+        normalBias,
+        normalMultiplier
+      );
+      uniforms.debugVisualize.value = debugVisualize;
+      const cam = camera;
+      if ("near" in cam) {
+        uniforms.cameraNear.value = cam.near;
+      }
+      if ("far" in cam) {
+        uniforms.cameraFar.value = cam.far;
+      }
+      composerRef.current.render();
+    }, 1);
+    useEffect(() => {
+      if (!composerRef.current || !outlinePassRef.current || !fxaaPassRef.current) return;
+      const width = Math.max(1, size.width * gl.getPixelRatio());
+      const height = Math.max(1, size.height * gl.getPixelRatio());
+      composerRef.current.setSize(width, height);
+      outlinePassRef.current.setSize(width, height);
+      fxaaPassRef.current.uniforms["resolution"].value.set(1 / width, 1 / height);
+    }, [size, gl]);
+    useImperativeHandle(ref, () => ({
+      updateMaxSurfaceId: (maxSurfaceId) => {
+        if (outlinePassRef.current) {
+          outlinePassRef.current.updateMaxSurfaceId(maxSurfaceId);
+        }
+      }
+    }));
+    return null;
+  }
+);
+OutlineEffect.displayName = "OutlineEffect";
+
+// src/utils/VertexWelder.ts
+function weldVertices(vertices, indices, thresholdAngle = 1) {
+  const mergedMap = {};
+  const vertexAliases = {};
+  function merge(i1, i2) {
+    if (mergedMap[i1] == void 0) mergedMap[i1] = [];
+    mergedMap[i1].push(i2);
+  }
+  function aliasDeletedVertex(deletedVertex, remainingVertex) {
+    if (deletedVertex == remainingVertex) return;
+    vertexAliases[deletedVertex] = remainingVertex;
+  }
+  const edgesToMerge = computeEdgesToMerge(vertices, indices, thresholdAngle);
+  const edgesToMergeMap = {};
+  for (let i = 0; i < edgesToMerge.length; i++) {
+    const edgesList = edgesToMerge[i];
+    for (const index of edgesList) {
+      const key = `${index[0]}_${index[1]}`;
+      edgesToMergeMap[key] = edgesList;
+    }
+  }
+  for (let i = 0; i < indices.length; i += 3) {
+    const i1 = indices[i + 0];
+    const i2 = indices[i + 1];
+    const i3 = indices[i + 2];
+    const edges = [];
+    edges.push([i1, i2]);
+    edges.push([i1, i3]);
+    edges.push([i2, i3]);
+    for (const edge of edges) {
+      let index0 = edge[0];
+      let index1 = edge[1];
+      const reverseEdge = [index1, index0];
+      let isReverse = false;
+      let edgeToMerge;
+      const edgeKey = `${edge[0]}_${edge[1]}`;
+      const reverseEdgeKey = `${reverseEdge[0]}_${reverseEdge[1]}`;
+      if (edgesToMergeMap[edgeKey]) {
+        edgeToMerge = edge;
+      }
+      if (edgesToMergeMap[reverseEdgeKey]) {
+        edgeToMerge = reverseEdge;
+        isReverse = true;
+      }
+      if (edgeToMerge) {
+        const edgeKeyToUse = isReverse ? reverseEdgeKey : edgeKey;
+        const possibleEdges = edgesToMergeMap[edgeKeyToUse];
+        const possibleEdge1 = possibleEdges[0];
+        const possibleEdge2 = possibleEdges[1];
+        let otherEdge = possibleEdge1;
+        let originalEdge = possibleEdge2;
+        if (possibleEdge1[0] == index0 && possibleEdge1[1] == index1 || possibleEdge1[0] == index1 && possibleEdge1[1] == index0) {
+          otherEdge = possibleEdge2;
+          originalEdge = possibleEdge1;
+        }
+        let index2 = otherEdge[0];
+        let index3 = otherEdge[1];
+        index0 = originalEdge[0];
+        index1 = originalEdge[1];
+        if (index0 == index2 && index1 == index3) {
+          continue;
+        }
+        const v0 = getVertexFromIndexBuffer(index0, vertices);
+        const v2 = getVertexFromIndexBuffer(index2, vertices);
+        if (v0.distanceTo(v2) > 0.1) {
+          const tmp = index3;
+          index3 = index2;
+          index2 = tmp;
+        }
+        if (vertexAliases[index0]) index0 = vertexAliases[index0];
+        if (vertexAliases[index1]) index1 = vertexAliases[index1];
+        if (vertexAliases[index2]) index2 = vertexAliases[index2];
+        if (vertexAliases[index3]) index3 = vertexAliases[index3];
+        merge(index0, index2);
+        merge(index1, index3);
+        aliasDeletedVertex(index2, index0);
+        aliasDeletedVertex(index3, index1);
+        const mergedEdgeKey = `${index2}_${index3}`;
+        delete edgesToMergeMap[edgeKeyToUse];
+        delete edgesToMergeMap[mergedEdgeKey];
+      }
+    }
+  }
+  const finalMergeMap = fillOutMergeMap(mergedMap);
+  const newIndexBuffer = [];
+  for (let i = 0; i < indices.length; i++) {
+    const index = indices[i];
+    let newIndex = index;
+    if (finalMergeMap[index] != void 0) {
+      newIndex = finalMergeMap[index];
+    }
+    newIndexBuffer.push(newIndex);
+  }
+  return newIndexBuffer;
+}
+function getVertexFromIndexBuffer(index, positionAttr) {
+  return new Vector3(
+    positionAttr[index * 3 + 0],
+    positionAttr[index * 3 + 1],
+    positionAttr[index * 3 + 2]
+  );
+}
+function fillOutMergeMap(mergeMap) {
+  const newMergeMap = {};
+  for (let i = 0; i < Object.keys(mergeMap).length; i++) {
+    const key = Number(Object.keys(mergeMap)[i]);
+    const indices = mergeMap[key];
+    for (const ind of indices) {
+      newMergeMap[ind] = key;
+    }
+  }
+  return newMergeMap;
+}
+var Vector3 = class _Vector3 {
+  constructor(x = 0, y = 0, z = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  clone() {
+    return new _Vector3(this.x, this.y, this.z);
+  }
+  set(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    return this;
+  }
+  distanceTo(v) {
+    const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  lengthSq() {
+    return this.x * this.x + this.y * this.y + this.z * this.z;
+  }
+  multiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    this.z *= scalar;
+    return this;
+  }
+  subVectors(a, b) {
+    this.x = a.x - b.x;
+    this.y = a.y - b.y;
+    this.z = a.z - b.z;
+    return this;
+  }
+  dot(v) {
+    return this.x * v.x + this.y * v.y + this.z * v.z;
+  }
+  cross(v) {
+    return this.crossVectors(this, v);
+  }
+  crossVectors(a, b) {
+    const ax = a.x, ay = a.y, az = a.z;
+    const bx = b.x, by = b.y, bz = b.z;
+    this.x = ay * bz - az * by;
+    this.y = az * bx - ax * bz;
+    this.z = ax * by - ay * bx;
+    return this;
+  }
+};
+var _v0 = new Vector3();
+var _normal = new Vector3();
+var precisionPoints = 4;
+var precision = Math.pow(10, precisionPoints);
+function hashVertex(v) {
+  return `${Math.round(v.x * precision)},${Math.round(v.y * precision)},${Math.round(
+    v.z * precision
+  )}`;
+}
+function getNormal(a, b, c, resultNormal) {
+  resultNormal.subVectors(c, b);
+  _v0.subVectors(a, b);
+  resultNormal.cross(_v0);
+  const targetLengthSq = resultNormal.lengthSq();
+  if (targetLengthSq > 0) {
+    return resultNormal.multiplyScalar(1 / Math.sqrt(targetLengthSq));
+  }
+  return resultNormal.set(0, 0, 0);
+}
+function computeEdgesToMerge(vertices, indices, thresholdAngle = 1) {
+  const DEG2RAD = Math.PI / 180;
+  const thresholdDot = Math.cos(DEG2RAD * thresholdAngle);
+  const indexCount = indices.length;
+  const indexArr = [0, 0, 0];
+  const hashes = new Array(3);
+  const edgeData = {};
+  const edgesToMerge = [];
+  for (let i = 0; i < indexCount; i += 3) {
+    indexArr[0] = indices[i];
+    indexArr[1] = indices[i + 1];
+    indexArr[2] = indices[i + 2];
+    const a = getVertexFromIndexBuffer(indexArr[0], vertices);
+    const b = getVertexFromIndexBuffer(indexArr[1], vertices);
+    const c = getVertexFromIndexBuffer(indexArr[2], vertices);
+    getNormal(a, b, c, _normal);
+    hashes[0] = hashVertex(a);
+    hashes[1] = hashVertex(b);
+    hashes[2] = hashVertex(c);
+    if (hashes[0] === hashes[1] || hashes[1] === hashes[2] || hashes[2] === hashes[0]) {
+      continue;
+    }
+    for (let j = 0; j < 3; j++) {
+      const jNext = (j + 1) % 3;
+      const vecHash0 = hashes[j];
+      const vecHash1 = hashes[jNext];
+      const hash = `${vecHash0}_${vecHash1}`;
+      const reverseHash = `${vecHash1}_${vecHash0}`;
+      if (reverseHash in edgeData && edgeData[reverseHash]) {
+        if (_normal.dot(edgeData[reverseHash].normal) > thresholdDot) {
+          const edge1 = [edgeData[reverseHash].index0, edgeData[reverseHash].index1];
+          const edge2 = [indexArr[j], indexArr[jNext]];
+          edgesToMerge.push([edge1, edge2]);
+        }
+        edgeData[reverseHash] = null;
+      } else if (!(hash in edgeData)) {
+        edgeData[hash] = {
+          index0: indexArr[j],
+          index1: indexArr[jNext],
+          normal: _normal.clone()
+        };
+      }
+    }
+  }
+  return edgesToMerge;
+}
+function useSurfaceIds(enabled = true) {
+  const { scene } = useThree();
+  useEffect(() => {
+    if (!enabled) return;
+    const findSurfaces = new FindSurfaces_default();
+    let maxSurfaceId = 0;
+    scene.traverse((object) => {
+      if (object instanceof THREE2.Mesh && object.geometry) {
+        const geometry = object.geometry;
+        const surfaceIdAttribute = findSurfaces.getSurfaceIdAttribute(object);
+        geometry.setAttribute("color", new THREE2.BufferAttribute(surfaceIdAttribute, 4));
+        maxSurfaceId = Math.max(maxSurfaceId, findSurfaces.surfaceId);
+      }
+    });
+    return () => {
+      scene.traverse((object) => {
+        if (object instanceof THREE2.Mesh && object.geometry) {
+          object.geometry.deleteAttribute("color");
+        }
+      });
+    };
+  }, [scene, enabled]);
+}
+var useSurfaceIds_default = useSurfaceIds;
+
+export { CustomOutlinePass, FindSurfaces_default as FindSurfaces, OutlineEffect, getDebugSurfaceIdMaterial, getSurfaceIdMaterial, useSurfaceIds_default as useSurfaceIds, weldVertices };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map