@pretty-chitty/core 1.1.1

package/dist/rendering/outline/passes/DebugIDMappingPass.d.ts

@@ -0,0 +1,20 @@
+import { ShaderMaterial, WebGLRenderer, WebGLRenderTarget, Color } from "three";
+import { Pass } from "../types";
+export declare class DebugIDMappingPass extends Pass {
+    debugMaterial: ShaderMaterial;
+    private fsQuad;
+    private selectedIDs;
+    clear: boolean;
+    needsSwap: boolean;
+    constructor();
+    setIDTexture(texture: any): void;
+    setTextureSize(width: number, height: number): void;
+    setOutliningMeshes(outliningMeshes: Array<{
+        id: number;
+        color: Color;
+    }>): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
+    private createDebugMaterial;
+    dispose(): void;
+}
+//# sourceMappingURL=DebugIDMappingPass.d.ts.map

package/dist/rendering/outline/passes/DebugIDMappingPass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DebugIDMappingPass.d.ts","sourceRoot":"","sources":["../../../../src/library/rendering/outline/passes/DebugIDMappingPass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EAEjB,KAAK,EACN,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGhC,qBAAa,kBAAmB,SAAQ,IAAI;IAC1C,aAAa,EAAE,cAAc,CAAC;IAC9B,OAAO,CAAC,MAAM,CAAiB;IAE/B,OAAO,CAAC,WAAW,CAAqB;IAExC,KAAK,UAAQ;IACb,SAAS,UAAS;;IAQlB,YAAY,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;IAIhC,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAInD,kBAAkB,CAAC,eAAe,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,CAAC,GAAG,IAAI;IAoC5E,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,GAAG,IAAI;IAMrE,OAAO,CAAC,mBAAmB;IA0E3B,OAAO,IAAI,IAAI;CAIhB"}

package/dist/rendering/outline/passes/DebugIDMappingPass.js

@@ -0,0 +1,131 @@
+import { ShaderMaterial, Vector2, } from "three";
+import { Pass } from "../types";
+import { FullScreenQuad } from "../FullScreenQuad";
+export class DebugIDMappingPass extends Pass {
+    constructor() {
+        super();
+        this.selectedIDs = new Set();
+        this.clear = true;
+        this.needsSwap = false;
+        this.debugMaterial = this.createDebugMaterial();
+        this.fsQuad = new FullScreenQuad(this.debugMaterial);
+    }
+    setIDTexture(texture) {
+        this.debugMaterial.uniforms["idTexture"].value = texture;
+    }
+    setTextureSize(width, height) {
+        this.debugMaterial.uniforms["texSize"].value.set(width, height);
+    }
+    setOutliningMeshes(outliningMeshes) {
+        this.selectedIDs.clear();
+        // Store ID to color mapping
+        const maxMeshes = 64;
+        const idColors = new Float32Array(maxMeshes * 3); // RGB for each mesh
+        const idList = new Float32Array(maxMeshes * 3); // ID encoded as RGB for each mesh
+        let index = 0;
+        for (const mesh of outliningMeshes) {
+            if (index >= maxMeshes)
+                break;
+            this.selectedIDs.add(mesh.id);
+            // Store the outline color for this mesh
+            idColors[index * 3] = mesh.color.r;
+            idColors[index * 3 + 1] = mesh.color.g;
+            idColors[index * 3 + 2] = mesh.color.b;
+            // Store the ID encoded as RGB
+            const r = ((mesh.id >> 16) & 0xff) / 255.0;
+            const g = ((mesh.id >> 8) & 0xff) / 255.0;
+            const b = (mesh.id & 0xff) / 255.0;
+            idList[index * 3] = r;
+            idList[index * 3 + 1] = g;
+            idList[index * 3 + 2] = b;
+            index++;
+        }
+        this.debugMaterial.uniforms["meshOutlineColors"].value = idColors;
+        this.debugMaterial.uniforms["meshIDColors"].value = idList;
+        this.debugMaterial.uniforms["numOutlineMeshes"].value = Math.min(outliningMeshes.length, maxMeshes);
+    }
+    render(renderer, writeBuffer) {
+        renderer.setRenderTarget(writeBuffer);
+        if (this.clear)
+            renderer.clear();
+        this.fsQuad.render(renderer);
+    }
+    createDebugMaterial() {
+        return new ShaderMaterial({
+            uniforms: {
+                idTexture: { value: null },
+                texSize: { value: new Vector2(0.5, 0.5) },
+                meshOutlineColors: { value: new Float32Array(64 * 3) }, // RGB color for each outlined mesh
+                meshIDColors: { value: new Float32Array(64 * 3) }, // ID encoded as RGB for each outlined mesh
+                numOutlineMeshes: { value: 0 },
+            },
+            vertexShader: `varying vec2 vUv;
+        void main() {
+          vUv = uv;
+          gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+        }`,
+            fragmentShader: `
+        uniform sampler2D idTexture;
+        uniform vec2 texSize;
+        uniform float[192] meshOutlineColors; // 64 * 3 (RGB outline colors)
+        uniform float[192] meshIDColors; // 64 * 3 (RGB encoded IDs)
+        uniform int numOutlineMeshes;
+        varying vec2 vUv;
+
+        // Compare two RGB colors (object IDs) by rounding to nearest byte value
+        // This handles precision loss from reduced color depth devices (e.g., 6-bit displays)
+        bool colorsMatch(vec3 color1, vec3 color2) {
+          // Round both colors to nearest byte values
+          vec3 c1 = floor(color1 * 255.0 + 0.5);
+          vec3 c2 = floor(color2 * 255.0 + 0.5);
+          return c1.r == c2.r && c1.g == c2.g && c1.b == c2.b;
+        }
+
+        // Check if a color represents background (black/near-black)
+        bool isBackground(vec3 color) {
+          return color.r < 0.01 && color.g < 0.01 && color.b < 0.01;
+        }
+
+        // Find the outline color for a given mesh ID color, returns vec4(outlineColor, 1.0) or vec4(0,0,0,0) if not outlined
+        vec4 getOutlineColor(vec3 idColor) {
+          if (isBackground(idColor)) return vec4(0.0, 0.0, 0.0, 0.0);
+
+          for (int i = 0; i < numOutlineMeshes && i < 64; i++) {
+            vec3 meshIDColor = vec3(
+              meshIDColors[i * 3],
+              meshIDColors[i * 3 + 1],
+              meshIDColors[i * 3 + 2]
+            );
+
+            if (colorsMatch(idColor, meshIDColor)) {
+              vec3 outlineColor = vec3(
+                meshOutlineColors[i * 3],
+                meshOutlineColors[i * 3 + 1],
+                meshOutlineColors[i * 3 + 2]
+              );
+              return vec4(outlineColor, 1.0);
+            }
+          }
+          return vec4(0.0, 0.0, 0.0, 0.0);
+        }
+
+        void main() {
+          // Sample the ID texture - this now contains outline colors directly
+          vec4 outlineColor = texture2D(idTexture, vUv);
+
+          if (isBackground(outlineColor.rgb)) {
+            // Show black for background
+            gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+          } else {
+            // Show the outline color directly
+            gl_FragColor = vec4(outlineColor.rgb, 1.0);
+          }
+        }`,
+        });
+    }
+    dispose() {
+        this.debugMaterial.dispose();
+        this.fsQuad.dispose();
+    }
+}
+//# sourceMappingURL=DebugIDMappingPass.js.map

package/dist/rendering/outline/passes/DebugIDMappingPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DebugIDMappingPass.js","sourceRoot":"","sources":["../../../../src/library/rendering/outline/passes/DebugIDMappingPass.ts"],"names":[],"mappings":"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"}

package/dist/rendering/outline/passes/DepthOcclusionPass.d.ts

@@ -0,0 +1,24 @@
+import { WebGLRenderer, WebGLRenderTarget } from "three";
+import { Pass } from "../types";
+/**
+ * DepthOcclusionPass - Filters input buffer based on depth comparison
+ *
+ * Takes an input buffer (e.g., from IDBasedOutlinePass edge detection) and
+ * compares its depth values against the original scene's depth buffer.
+ * Clears pixels where the original scene is in front (occluding the input).
+ */
+export declare class DepthOcclusionPass extends Pass {
+    private material;
+    private fsQuad;
+    clear: boolean;
+    needsSwap: boolean;
+    constructor();
+    setInputTexture(texture: any): void;
+    setIDDepthTexture(depthTexture: any): void;
+    setSceneDepthTexture(depthTexture: any): void;
+    setDepthTolerance(tolerance: number): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
+    private createMaterial;
+    dispose(): void;
+}
+//# sourceMappingURL=DepthOcclusionPass.d.ts.map

package/dist/rendering/outline/passes/DepthOcclusionPass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepthOcclusionPass.d.ts","sourceRoot":"","sources":["../../../../src/library/rendering/outline/passes/DepthOcclusionPass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,aAAa,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AACzE,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGhC;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,IAAI;IAC1C,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,MAAM,CAAiB;IAE/B,KAAK,UAAQ;IACb,SAAS,UAAS;;IASlB,eAAe,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;IAInC,iBAAiB,CAAC,YAAY,EAAE,GAAG,GAAG,IAAI;IAI1C,oBAAoB,CAAC,YAAY,EAAE,GAAG,GAAG,IAAI;IAI7C,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI1C,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,GAAG,IAAI;IAMrE,OAAO,CAAC,cAAc;IAsDtB,OAAO,IAAI,IAAI;CAIhB"}

package/dist/rendering/outline/passes/DepthOcclusionPass.js

@@ -0,0 +1,95 @@
+import { ShaderMaterial } from "three";
+import { Pass } from "../types";
+import { FullScreenQuad } from "../FullScreenQuad";
+/**
+ * DepthOcclusionPass - Filters input buffer based on depth comparison
+ *
+ * Takes an input buffer (e.g., from IDBasedOutlinePass edge detection) and
+ * compares its depth values against the original scene's depth buffer.
+ * Clears pixels where the original scene is in front (occluding the input).
+ */
+export class DepthOcclusionPass extends Pass {
+    constructor() {
+        super();
+        this.clear = true;
+        this.needsSwap = false;
+        this.material = this.createMaterial();
+        this.fsQuad = new FullScreenQuad(this.material);
+    }
+    setInputTexture(texture) {
+        this.material.uniforms["inputTexture"].value = texture;
+    }
+    setIDDepthTexture(depthTexture) {
+        this.material.uniforms["idDepthTexture"].value = depthTexture;
+    }
+    setSceneDepthTexture(depthTexture) {
+        this.material.uniforms["sceneDepthTexture"].value = depthTexture;
+    }
+    setDepthTolerance(tolerance) {
+        this.material.uniforms["depthTolerance"].value = tolerance;
+    }
+    render(renderer, writeBuffer) {
+        renderer.setRenderTarget(writeBuffer);
+        if (this.clear)
+            renderer.clear();
+        this.fsQuad.render(renderer);
+    }
+    createMaterial() {
+        return new ShaderMaterial({
+            uniforms: {
+                inputTexture: { value: null },
+                idDepthTexture: { value: null },
+                sceneDepthTexture: { value: null },
+                depthTolerance: { value: 0.0001 },
+            },
+            vertexShader: `
+        varying vec2 vUv;
+
+        void main() {
+          vUv = uv;
+          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+        }
+      `,
+            fragmentShader: `
+        uniform sampler2D inputTexture;
+        uniform sampler2D idDepthTexture;
+        uniform sampler2D sceneDepthTexture;
+        uniform float depthTolerance;
+        varying vec2 vUv;
+
+        void main() {
+          // Sample the input texture (edge detection results)
+          vec4 inputColor = texture2D(inputTexture, vUv);
+
+          // If input is transparent, output transparent
+          if (inputColor.a < 0.01) {
+            gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+            return;
+          }
+
+          // Sample depth values
+          float idDepth = texture2D(idDepthTexture, vUv).r;
+          float sceneDepth = texture2D(sceneDepthTexture, vUv).r;
+
+          // If scene depth is in front (less than) ID depth, the outline is occluded
+          // Clear the pixel by outputting transparent
+          if (sceneDepth < idDepth - depthTolerance) {
+            gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+            return;
+          }
+
+          // Otherwise, pass through the input color
+          gl_FragColor = inputColor;
+        }
+      `,
+            transparent: true,
+            depthTest: false,
+            depthWrite: false,
+        });
+    }
+    dispose() {
+        this.material.dispose();
+        this.fsQuad.dispose();
+    }
+}
+//# sourceMappingURL=DepthOcclusionPass.js.map

package/dist/rendering/outline/passes/DepthOcclusionPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepthOcclusionPass.js","sourceRoot":"","sources":["../../../../src/library/rendering/outline/passes/DepthOcclusionPass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAoC,MAAM,OAAO,CAAC;AACzE,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,OAAO,kBAAmB,SAAQ,IAAI;IAO1C;QACE,KAAK,EAAE,CAAC;QAJV,UAAK,GAAG,IAAI,CAAC;QACb,cAAS,GAAG,KAAK,CAAC;QAKhB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACtC,IAAI,CAAC,MAAM,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;IAED,eAAe,CAAC,OAAY;QAC1B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC;IACzD,CAAC;IAED,iBAAiB,CAAC,YAAiB;QACjC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,KAAK,GAAG,YAAY,CAAC;IAChE,CAAC;IAED,oBAAoB,CAAC,YAAiB;QACpC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,KAAK,GAAG,YAAY,CAAC;IACnE,CAAC;IAED,iBAAiB,CAAC,SAAiB;QACjC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,KAAK,GAAG,SAAS,CAAC;IAC7D,CAAC;IAED,MAAM,CAAC,QAAuB,EAAE,WAA8B;QAC5D,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;QACtC,IAAI,IAAI,CAAC,KAAK;YAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;IAEO,cAAc;QACpB,OAAO,IAAI,cAAc,CAAC;YACxB,QAAQ,EAAE;gBACR,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;gBAC7B,cAAc,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;gBAC/B,iBAAiB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE;gBAClC,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;aAClC;YACD,YAAY,EAAE;;;;;;;OAOb;YACD,cAAc,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+Bf;YACD,WAAW,EAAE,IAAI;YACjB,SAAS,EAAE,KAAK;YAChB,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;IACL,CAAC;IAED,OAAO;QACL,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;QACxB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;CACF"}

package/dist/rendering/outline/passes/InterMeshEdgeDetectionPass.d.ts

@@ -0,0 +1,32 @@
+import { ShaderMaterial, WebGLRenderer, WebGLRenderTarget, Color } from "three";
+import { Pass } from "../types";
+export declare enum EdgeMode {
+    SELECTED_ONLY = "selected_only",// Only edges around selected objects (current behavior)
+    ALL_MESHES = "all_meshes",// Edges between any different mesh IDs
+    MESH_BOUNDARIES = "mesh_boundaries",// Edges between meshes and background
+    SELECTED_AND_BOUNDARIES = "selected_and_boundaries"
+}
+export declare class InterMeshEdgeDetectionPass extends Pass {
+    edgeDetectionMaterial: ShaderMaterial;
+    private fsQuad;
+    backgroundThreshold: number;
+    private selectedIDs;
+    private lookupTexture;
+    clear: boolean;
+    needsSwap: boolean;
+    constructor();
+    setIDTexture(texture: any): void;
+    setIDDepthTexture(depthTexture: any): void;
+    setTextureSize(width: number, height: number): void;
+    setThickness(thickness: number): void;
+    setStrength(strength: number): void;
+    setStepSize(stepSize: number): void;
+    setOutliningMeshes(outliningMeshes: Array<{
+        id: number;
+        color: Color;
+    }>): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
+    private createEdgeDetectionMaterial;
+    dispose(): void;
+}
+//# sourceMappingURL=InterMeshEdgeDetectionPass.d.ts.map

package/dist/rendering/outline/passes/InterMeshEdgeDetectionPass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InterMeshEdgeDetectionPass.d.ts","sourceRoot":"","sources":["../../../../src/library/rendering/outline/passes/InterMeshEdgeDetectionPass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,aAAa,EACb,iBAAiB,EAGjB,KAAK,EAKN,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGhC,oBAAY,QAAQ;IAClB,aAAa,kBAAkB,CAAE,wDAAwD;IACzF,UAAU,eAAe,CAAE,uCAAuC;IAClE,eAAe,oBAAoB,CAAE,sCAAsC;IAC3E,uBAAuB,4BAA4B;CACpD;AAED,qBAAa,0BAA2B,SAAQ,IAAI;IAClD,qBAAqB,EAAE,cAAc,CAAC;IACtC,OAAO,CAAC,MAAM,CAAiB;IAG/B,mBAAmB,SAAQ;IAE3B,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,aAAa,CAAc;IAEnC,KAAK,UAAQ;IACb,SAAS,UAAS;;IAiBlB,YAAY,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;IAIhC,iBAAiB,CAAC,YAAY,EAAE,GAAG,GAAG,IAAI;IAI1C,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAInD,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAInC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKnC,kBAAkB,CAAC,eAAe,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,GAAG,IAAI;IA2B9E,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,GAAG,IAAI;IASrE,OAAO,CAAC,2BAA2B;IAgInC,OAAO,IAAI,IAAI;CAIhB"}

package/dist/rendering/outline/passes/InterMeshEdgeDetectionPass.js

@@ -0,0 +1,208 @@
+import { ShaderMaterial, Vector2, DataTexture, RGBAFormat, FloatType, NearestFilter, } from "three";
+import { Pass } from "../types";
+import { FullScreenQuad } from "../FullScreenQuad";
+export var EdgeMode;
+(function (EdgeMode) {
+    EdgeMode["SELECTED_ONLY"] = "selected_only";
+    EdgeMode["ALL_MESHES"] = "all_meshes";
+    EdgeMode["MESH_BOUNDARIES"] = "mesh_boundaries";
+    EdgeMode["SELECTED_AND_BOUNDARIES"] = "selected_and_boundaries";
+})(EdgeMode || (EdgeMode = {}));
+export class InterMeshEdgeDetectionPass extends Pass {
+    constructor() {
+        super();
+        // Edge filtering
+        this.backgroundThreshold = 0.01; // RGB threshold to consider a pixel as background
+        this.selectedIDs = new Set();
+        this.clear = true;
+        this.needsSwap = false;
+        // Create lookup texture (256x256 to handle all possible IDs 0-65535)
+        const textureSize = 256;
+        const textureData = new Float32Array(textureSize * textureSize * 4); // RGBA
+        this.lookupTexture = new DataTexture(textureData, textureSize, textureSize, RGBAFormat, FloatType);
+        this.lookupTexture.minFilter = NearestFilter;
+        this.lookupTexture.magFilter = NearestFilter;
+        this.lookupTexture.needsUpdate = true;
+        this.edgeDetectionMaterial = this.createEdgeDetectionMaterial();
+        this.fsQuad = new FullScreenQuad(this.edgeDetectionMaterial);
+    }
+    setIDTexture(texture) {
+        this.edgeDetectionMaterial.uniforms["idTexture"].value = texture;
+    }
+    setIDDepthTexture(depthTexture) {
+        this.edgeDetectionMaterial.uniforms["idDepthTexture"].value = depthTexture;
+    }
+    setTextureSize(width, height) {
+        this.edgeDetectionMaterial.uniforms["texSize"].value.set(width, height);
+    }
+    setThickness(thickness) {
+        this.edgeDetectionMaterial.uniforms["thickness"].value = thickness;
+    }
+    setStrength(strength) {
+        this.edgeDetectionMaterial.uniforms["strength"].value = strength;
+    }
+    setStepSize(stepSize) {
+        this.edgeDetectionMaterial.uniforms["stepSize"].value = stepSize;
+    }
+    setOutliningMeshes(outliningMeshes) {
+        this.selectedIDs.clear();
+        // Clear lookup texture
+        const textureData = this.lookupTexture.image.data;
+        textureData.fill(0);
+        // Populate lookup texture with ID->Color mappings
+        for (const mesh of outliningMeshes) {
+            this.selectedIDs.add(mesh.id);
+            // Convert ID to texture coordinates
+            const id = mesh.id;
+            const x = id % 256;
+            const y = Math.floor(id / 256);
+            const index = (y * 256 + x) * 4;
+            // Store outline color at this position
+            textureData[index] = mesh.color.r; // R
+            textureData[index + 1] = mesh.color.g; // G
+            textureData[index + 2] = mesh.color.b; // B
+            textureData[index + 3] = 1.0; // A (indicates valid entry)
+        }
+        this.lookupTexture.needsUpdate = true;
+    }
+    render(renderer, writeBuffer) {
+        // Update uniforms that still exist
+        this.edgeDetectionMaterial.uniforms["backgroundThreshold"].value = this.backgroundThreshold;
+        renderer.setRenderTarget(writeBuffer);
+        if (this.clear)
+            renderer.clear();
+        this.fsQuad.render(renderer);
+    }
+    createEdgeDetectionMaterial() {
+        return new ShaderMaterial({
+            uniforms: {
+                idTexture: { value: null },
+                idDepthTexture: { value: null },
+                texSize: { value: new Vector2(0.5, 0.5) },
+                backgroundThreshold: { value: 0.01 },
+                lookupTexture: { value: this.lookupTexture },
+                thickness: { value: 4.0 },
+                strength: { value: 1.0 },
+                stepSize: { value: 1.0 },
+            },
+            vertexShader: `varying vec2 vUv;
+        void main() {
+          vUv = uv;
+          gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+        }`,
+            fragmentShader: `
+        uniform sampler2D idTexture;
+        uniform sampler2D idDepthTexture;
+        uniform vec2 texSize;
+        uniform float backgroundThreshold;
+        uniform sampler2D lookupTexture;
+        uniform float thickness;
+        uniform float strength;
+        uniform float stepSize;
+        varying vec2 vUv;
+
+        // Compare two RGB colors (object IDs) with tolerance
+        bool colorsMatch(vec3 color1, vec3 color2) {
+          vec3 diff = abs(color1 - color2);
+          return diff.r < 0.001 && diff.g < 0.001 && diff.b < 0.001;
+        }
+
+        // Check if a color represents background (black/near-black)
+        bool isBackground(vec3 color) {
+          return color.r < backgroundThreshold && color.g < backgroundThreshold && color.b < backgroundThreshold;
+        }
+
+        // Safely sample texture, treating out-of-bounds as background
+        vec4 sampleTextureClampToBackground(sampler2D tex, vec2 uv) {
+          if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+            return vec4(0.0, 0.0, 0.0, 0.0); // Background
+          }
+          return texture2D(tex, uv);
+        }
+
+        // Decode ID from RGB and lookup outline color in texture
+        vec4 getOutlineColor(vec3 encodedIdColor) {
+          if (isBackground(encodedIdColor)) {
+            return vec4(0.0, 0.0, 0.0, 0.0);
+          }
+
+          // Decode ID from RGB with rounding to handle precision loss from reduced color depth devices
+          // Round to nearest integer byte value to handle quantization errors
+          float r = floor(encodedIdColor.r * 255.0 + 0.5);
+          float g = floor(encodedIdColor.g * 255.0 + 0.5);
+          float b = floor(encodedIdColor.b * 255.0 + 0.5);
+          float id = r * 65536.0 + g * 256.0 + b;
+
+          // Convert ID to texture coordinates
+          float x = mod(id, 256.0) / 256.0;
+          float y = floor(id / 256.0) / 256.0;
+
+          // Lookup outline color
+          vec4 outlineColor = texture2D(lookupTexture, vec2(x, y));
+
+          // Return color if valid (alpha > 0), otherwise transparent
+          if (outlineColor.a > 0.5) {
+            return vec4(outlineColor.rgb, 1.0);
+          }
+          return vec4(0.0, 0.0, 0.0, 0.0);
+        }
+
+
+        void main() {
+          vec2 lowResInvSize = 1.0 / texSize;
+
+          // Sample the center pixel - MUST belong to an outlined mesh
+          vec4 center = texture2D(idTexture, vUv);
+          vec4 centerOutlineColor = getOutlineColor(center.rgb);
+
+          // Only draw outlines INSIDE meshes that have outline colors
+          if (centerOutlineColor.a < 0.5) {
+            gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+            return;
+          }
+
+          // Check neighbors to see if we're near an edge
+          float edgeDistance = 1000.0; // Very far away initially
+
+          float checkRadius = max(1.0, thickness);
+          float step = max(1.0, stepSize);
+          for (float x = -checkRadius; x <= checkRadius; x += step) {
+            for (float y = -checkRadius; y <= checkRadius; y += step) {
+              vec2 sampleUv = vUv + vec2(x, y) * lowResInvSize;
+              vec4 neighbor = texture2D(idTexture, sampleUv);
+
+              vec2 sampleUv2 = vUv + vec2(x*2.0, y*2.0) * lowResInvSize;
+              vec4 neighbor2 = texture2D(idTexture, sampleUv2);
+
+              // Edge detection: neighbor is different if colors don't match
+              if ((!colorsMatch(center.rgb, neighbor.rgb) &&
+                (!colorsMatch(center.rgb, neighbor2.rgb)))) {
+                float dist = length(vec2(x, y));
+                edgeDistance = min(edgeDistance, dist);
+              }
+            }
+          }
+
+          // Only draw if we're near an edge (inside the mesh)
+          if (edgeDistance < 1000.0) {
+            // Create thick outline with smooth falloff
+            float lineThickness = thickness + 0.5;
+            float alpha = 1.0 - smoothstep(0.5, lineThickness, edgeDistance);
+
+            if (alpha > 0.01) {
+              gl_FragColor = vec4(centerOutlineColor.rgb, alpha * strength);
+            } else {
+              gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+            }
+          } else {
+            gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+          }
+        }`,
+        });
+    }
+    dispose() {
+        this.edgeDetectionMaterial.dispose();
+        this.fsQuad.dispose();
+    }
+}
+//# sourceMappingURL=InterMeshEdgeDetectionPass.js.map

package/dist/rendering/outline/passes/InterMeshEdgeDetectionPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InterMeshEdgeDetectionPass.js","sourceRoot":"","sources":["../../../../src/library/rendering/outline/passes/InterMeshEdgeDetectionPass.ts"],"names":[],"mappings":"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"}

package/dist/rendering/outline/shaders.d.ts

@@ -0,0 +1,20 @@
+import type { IUniform } from "three";
+export declare const CopyShader: {
+    readonly uniforms: Record<string, IUniform>;
+    readonly vertexShader: string;
+    readonly fragmentShader: string;
+};
+export declare const OutputShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        toneMappingExposure: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+//# sourceMappingURL=shaders.d.ts.map

package/dist/rendering/outline/shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.d.ts","sourceRoot":"","sources":["../../../src/library/rendering/outline/shaders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,eAAO,MAAM,UAAU;uBAIhB,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;;;CAmBrB,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;;;;;;;CAkFxB,CAAC"}