threejs-debug-compose 0.1.0

package/dist/shader-cost/material-cost.js

@@ -0,0 +1,302 @@
+import { Material as e, MeshBasicMaterial as t, MeshLambertMaterial as n, MeshMatcapMaterial as r, MeshPhongMaterial as i, MeshPhysicalMaterial as a, MeshStandardMaterial as o, MeshToonMaterial as s, ShaderMaterial as c } from "three";
+//#region components/debug-views/shader-cost/material-cost.ts
+var l = 12, u = [
+	"map",
+	"normalMap",
+	"roughnessMap",
+	"metalnessMap",
+	"aoMap",
+	"emissiveMap",
+	"alphaMap",
+	"envMap",
+	"clearcoatMap",
+	"clearcoatNormalMap",
+	"clearcoatRoughnessMap",
+	"iridescenceMap",
+	"sheenColorMap",
+	"sheenRoughnessMap",
+	"transmissionMap"
+], d = [
+	"alphaTest",
+	"clearcoat",
+	"iridescence",
+	"sheen",
+	"transmission"
+], f = [
+	{
+		name: "texture-sample",
+		pattern: /\btexture(?:2D|Cube)?\s*\(/g
+	},
+	{
+		name: "branch",
+		pattern: /\b(?:if|switch)\b/g
+	},
+	{
+		name: "loop",
+		pattern: /\b(?:for|while|do)\b/g
+	},
+	{
+		name: "derivative",
+		pattern: /\b(?:dFdx|dFdy|fwidth)\s*\(/g
+	}
+], p = new Set(y(new e()));
+function m() {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		get(t) {
+			let n = h(t), r = e.get(t.uuid);
+			if (r?.signature === n) return r;
+			let i = g(t, n);
+			return e.set(t.uuid, i), i;
+		},
+		clear() {
+			e.clear();
+		},
+		get size() {
+			return e.size;
+		}
+	};
+}
+function h(e) {
+	return b(e);
+}
+function g(e, t = h(e)) {
+	let n = _(y(e));
+	return {
+		cost: v(n.length),
+		signature: t,
+		signals: n
+	};
+}
+function _(e) {
+	return e.filter((e) => !p.has(e));
+}
+function v(e) {
+	return Math.max(0, Math.min(1, e / l));
+}
+function y(e) {
+	let t = [];
+	return x(t, e), S(t, e), C(t, e), w(t, e), T(t, e), E(t, e), t;
+}
+function b(e) {
+	let t = [];
+	return x(t, e), S(t, e), C(t, e), w(t, e), D(t, e), t.join("|");
+}
+function x(e, l) {
+	if (l instanceof t) {
+		e.push("type:basic-unlit");
+		return;
+	}
+	if (l instanceof a) {
+		e.push("type:physical-lit", "lighting:pbr", "brdf:physical");
+		return;
+	}
+	if (l instanceof o) {
+		e.push("type:standard-lit", "lighting:pbr");
+		return;
+	}
+	if (l instanceof i) {
+		e.push("type:phong-lit", "lighting:phong", "specular:phong");
+		return;
+	}
+	if (l instanceof s) {
+		e.push("type:toon-lit", "lighting:toon");
+		return;
+	}
+	if (l instanceof n) {
+		e.push("type:lambert-lit", "lighting:lambert");
+		return;
+	}
+	if (l instanceof r) {
+		e.push("type:matcap", "lighting:matcap");
+		return;
+	}
+	if (l instanceof c) {
+		e.push("type:custom-shader");
+		return;
+	}
+	e.push(`type:${l.type}`);
+}
+function S(e, t) {
+	e.push(`side:${t.side}`, `blending:${t.blending}`), t.transparent && e.push("transparent:true"), J(t, "clippingPlanes") > 0 && e.push(`clippingPlanes:${J(t, "clippingPlanes")}`);
+}
+function C(e, t) {
+	for (let n of u) {
+		let r = K(t, n);
+		r && e.push(U(n, r));
+	}
+}
+function w(e, t) {
+	for (let n of d) {
+		let r = q(t, n);
+		r > 0 && e.push(`${n}:${r}`);
+	}
+}
+function T(e, t) {
+	if (t instanceof c) for (let [n, r] of R(t)) e.push(`define:${n}:${String(r)}`);
+}
+function E(e, t) {
+	if (!(t instanceof c)) return;
+	let n = z(t);
+	O(e, "fragment", j(t.fragmentShader, n)), O(e, "vertex", j(t.vertexShader, n));
+}
+function D(e, t) {
+	t instanceof c && (T(e, t), e.push(`fragmentShader:${H(t.fragmentShader)}`), e.push(`vertexShader:${H(t.vertexShader)}`));
+}
+function O(e, t, n) {
+	k(e, `${t}:source-kb`, Math.ceil(n.length / 1024));
+	for (let { name: r, pattern: i } of f) k(e, `${t}:${r}`, A(n, i));
+}
+function k(e, t, n) {
+	if (!(n <= 0)) {
+		if (n === 1) {
+			e.push(t);
+			return;
+		}
+		for (let r = 1; r <= n; r += 1) e.push(`${t}:${r}`);
+	}
+}
+function A(e, t) {
+	t.lastIndex = 0;
+	let n = 0;
+	for (; t.exec(e);) n += 1;
+	return t.lastIndex = 0, n;
+}
+function j(e, t) {
+	let n = [], r = [];
+	for (let i of e.split(/\r?\n/)) {
+		let e = M(i, t);
+		if (e) {
+			N(r, e);
+			continue;
+		}
+		r.every((e) => e.active) && n.push(i);
+	}
+	return n.join("\n");
+}
+function M(e, t) {
+	let n = e.trim();
+	return n.startsWith("#ifdef ") ? {
+		type: "open",
+		active: B(t, n.slice(7).trim())
+	} : n.startsWith("#ifndef ") ? {
+		type: "open",
+		active: !B(t, n.slice(8).trim())
+	} : n.startsWith("#if ") ? {
+		type: "open",
+		active: P(n.slice(4).trim(), t)
+	} : n.startsWith("#elif ") ? {
+		type: "elif",
+		active: P(n.slice(6).trim(), t)
+	} : n === "#else" ? { type: "else" } : n === "#endif" ? { type: "close" } : null;
+}
+function N(e, t) {
+	if (t.type === "open") {
+		let n = e.every((e) => e.active);
+		e.push({
+			parentActive: n,
+			conditionActive: t.active,
+			active: n && t.active,
+			branchMatched: t.active
+		});
+		return;
+	}
+	if (t.type === "elif") {
+		let n = e[e.length - 1];
+		n && (n.conditionActive = !n.branchMatched && t.active, n.active = n.parentActive && n.conditionActive, n.branchMatched ||= t.active);
+		return;
+	}
+	if (t.type === "else") {
+		let t = e[e.length - 1];
+		t && (t.conditionActive = !t.branchMatched, t.active = t.parentActive && t.conditionActive, t.branchMatched = !0);
+		return;
+	}
+	e.pop();
+}
+function P(e, t) {
+	let n = F(e.trim());
+	if (n.includes("||")) return n.split("||").some((e) => P(e, t));
+	if (n.includes("&&")) return n.split("&&").every((e) => P(e, t));
+	if (n.startsWith("!")) return !P(n.slice(1), t);
+	if (n === "1") return !0;
+	if (n === "0") return !1;
+	let r = n.match(/^defined\((\w+)\)$/);
+	if (r) return B(t, r[1] ?? "");
+	let i = n.match(/^(\w+)\s*(==|!=|>=|<=|>|<)\s*([.\w-]+)$/);
+	return i ? I(t[i[1] ?? ""], i[2] ?? "", i[3] ?? "") : B(t, n);
+}
+function F(e) {
+	return !e.startsWith("(") || !e.endsWith(")") ? e : e.slice(1, -1).trim();
+}
+function I(e, t, n) {
+	let r = L(e), i = L(n);
+	switch (t) {
+		case "==": return r === i;
+		case "!=": return r !== i;
+		case ">": return Number(r) > Number(i);
+		case ">=": return Number(r) >= Number(i);
+		case "<": return Number(r) < Number(i);
+		case "<=": return Number(r) <= Number(i);
+		default: return !1;
+	}
+}
+function L(e) {
+	return e === !0 ? "1" : e === !1 || e == null ? "0" : String(e);
+}
+function R(e) {
+	return Object.entries(z(e)).filter(([, e]) => V(e));
+}
+function z(e) {
+	return X(e.defines) ? e.defines : {};
+}
+function B(e, t) {
+	return V(e[t]);
+}
+function V(e) {
+	return e != null && e !== !1 && e !== 0 && e !== "0";
+}
+function H(e) {
+	let t = 5381;
+	for (let n = 0; n < e.length; n += 1) t = t * 33 ^ e.charCodeAt(n);
+	return (t >>> 0).toString(36);
+}
+function U(e, t) {
+	return [
+		e,
+		"texture",
+		t.uuid,
+		t.version,
+		t.mapping,
+		t.magFilter,
+		t.minFilter,
+		t.wrapS,
+		t.wrapT,
+		W(t)
+	].join(":");
+}
+function W(e) {
+	return e.wrapR ?? "none";
+}
+function G(e, t) {
+	return e[t];
+}
+function K(e, t) {
+	let n = G(e, t);
+	return Y(n) ? n : null;
+}
+function q(e, t) {
+	let n = G(e, t);
+	return typeof n == "number" ? n : 0;
+}
+function J(e, t) {
+	let n = G(e, t);
+	return Array.isArray(n) ? n.length : 0;
+}
+function Y(e) {
+	return !!(e && typeof e == "object" && "isTexture" in e && e.isTexture);
+}
+function X(e) {
+	return !!(e && typeof e == "object" && !Array.isArray(e));
+}
+//#endregion
+export { m as createMaterialCostCache };

package/dist/types/custom-debug-view.d.ts

@@ -0,0 +1,17 @@
+import type { DebugNode } from "./debug-views-tsl/node-types";
+import type { DebugView, ViewMode } from "./debug-views-tsl/compositor";
+export interface CustomDebugNodeViewOptions {
+    /**
+     * Stable identity for render-graph deduping.
+     *
+     * Reuse the same id only when two views are expected to render the same node
+     * with the same visualization settings.
+     */
+    id: string;
+    label: string;
+    node: DebugNode;
+    mode?: ViewMode;
+    scale?: number;
+    bias?: number;
+}
+export declare function createCustomDebugView({ id, label, node, mode, scale, bias, }: CustomDebugNodeViewOptions): DebugView;

package/dist/types/debug-render-graph-plan.d.ts

@@ -0,0 +1,17 @@
+import type { Camera } from "three";
+import type { DebugView } from "./debug-views-tsl/compositor";
+import type { DebugViewportCell, DebugViewportPlan, DebugViewportResolutionScale } from "./debug-viewport-plan";
+export interface DebugViewportRenderPassPlan {
+    key: string;
+    view: DebugView;
+    camera?: Camera;
+    resolutionScale: DebugViewportResolutionScale;
+}
+export interface DebugViewportRenderGraphCell extends DebugViewportCell {
+    passIndex: number;
+}
+export interface DebugViewportRenderGraphPlan {
+    passes: DebugViewportRenderPassPlan[];
+    cells: DebugViewportRenderGraphCell[];
+}
+export declare function createDebugViewportRenderGraphPlan(plan: DebugViewportPlan): DebugViewportRenderGraphPlan;

package/dist/types/debug-render-plan.d.ts

@@ -0,0 +1,26 @@
+import { type Texture, type TextureDataType } from "three";
+import type { DebugView } from "./debug-views-tsl/compositor";
+import type { MaterialDetailOutputs, SceneDebugOutputs } from "./debug-views-tsl/default-debug-nodes";
+import type { DebugViewLayout, ResolvedDebugViewLayout } from "./debug-view-layout";
+export interface DebugTextureTypeOverride {
+    name: string;
+    type: TextureDataType;
+}
+export interface TextureTypedDebugPass {
+    getTexture(name: string): Texture;
+}
+export interface DebugRenderPlan {
+    views: DebugView[];
+    sceneOutputs: SceneDebugOutputs;
+    materialDetailOutputs: MaterialDetailOutputs;
+    usesMaterialDetailPass: boolean;
+    usesWireframePass: boolean;
+    usesLightingOnlyPass: boolean;
+    usesReflectionOnlyPass: boolean;
+    usesShaderCostPass: boolean;
+    usesAoFallback: boolean;
+    sceneTextureTypes: DebugTextureTypeOverride[];
+    materialDetailTextureTypes: DebugTextureTypeOverride[];
+}
+export declare function createDebugRenderPlan(views: readonly DebugView[], activeView: number, layout: DebugViewLayout | ResolvedDebugViewLayout): DebugRenderPlan;
+export declare function applyDebugTextureTypes(passNode: TextureTypedDebugPass, overrides: readonly DebugTextureTypeOverride[]): void;

package/dist/types/debug-view-definitions.d.ts

@@ -0,0 +1,60 @@
+import type { DebugView } from "./debug-views-tsl/compositor";
+export declare const MATERIAL_DEBUG_VIEW_SOURCES: readonly ["albedo", "materialNormal", "normalMap", "emissive", "roughness", "ao", "metallic", "opacity", "wireframe", "lightingOnly", "reflectionOnly", "shaderCost"];
+export declare const DEFAULT_DEBUG_VIEWS: readonly [{
+    readonly label: "Beauty";
+    readonly source: "beauty";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Normal";
+    readonly source: "normal";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Depth";
+    readonly source: "depth";
+    readonly mode: "depth";
+}, {
+    readonly label: "Base Color / Albedo";
+    readonly source: "albedo";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Material Normal / Normal Map";
+    readonly source: "materialNormal";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Emissive";
+    readonly source: "emissive";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Roughness";
+    readonly source: "roughness";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "AO";
+    readonly source: "ao";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Metallic";
+    readonly source: "metallic";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Opacity";
+    readonly source: "opacity";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Wireframe";
+    readonly source: "wireframe";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Lighting Only";
+    readonly source: "lightingOnly";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Reflection Only";
+    readonly source: "reflectionOnly";
+    readonly mode: "passthrough";
+}, {
+    readonly label: "Estimated Shader Complexity";
+    readonly source: "shaderCost";
+    readonly mode: "heatmap";
+}];
+export declare function getDebugViewLabels(views?: readonly DebugView[]): string[];

package/dist/types/debug-view-layout.d.ts

@@ -0,0 +1,21 @@
+export type LayoutMode = "single" | "overlay" | "split-h" | "split-v" | "quad" | "row" | "column" | "grid";
+export interface DebugViewLayoutOptions {
+    slots?: number;
+    columns?: number;
+    rows?: number;
+}
+export interface DebugViewLayoutConfig extends DebugViewLayoutOptions {
+    mode: LayoutMode;
+}
+export type DebugViewLayout = LayoutMode | DebugViewLayoutConfig;
+export type LayoutPresentation = "single" | "overlay" | "grid";
+export interface ResolvedDebugViewLayout {
+    mode: LayoutMode;
+    presentation: LayoutPresentation;
+    columns: number;
+    rows: number;
+    slots: number;
+}
+export declare const LAYOUT_INDEX: Record<LayoutMode, number>;
+export declare function resolveDebugViewLayout(layout?: DebugViewLayout, options?: DebugViewLayoutOptions): ResolvedDebugViewLayout;
+export declare function isResolvedDebugViewLayout(layout: DebugViewLayout | ResolvedDebugViewLayout): layout is ResolvedDebugViewLayout;

package/dist/types/debug-view-selection.d.ts

@@ -0,0 +1,5 @@
+import type { DebugView, DebugViewSource, ViewMode } from "./debug-views-tsl/compositor";
+import { type DebugViewLayout, type ResolvedDebugViewLayout } from "./debug-view-layout";
+export declare function getDefaultDebugViewSource(view: DebugView): DebugViewSource;
+export declare function getResolvedDebugViewMode(view: DebugView): ViewMode;
+export declare function selectPipelineViews(views: readonly DebugView[], activeView: number, layout: DebugViewLayout | ResolvedDebugViewLayout): DebugView[];

package/dist/types/debug-viewport-labels.d.ts

@@ -0,0 +1,8 @@
+import type { DebugView } from "./debug-views-tsl/compositor";
+import type { ResolvedDebugViewLayout } from "./debug-view-layout";
+import type { DebugViewportPlan } from "./debug-viewport-plan";
+export type DebugViewportLabel = string | undefined;
+export type DebugViewportLabelFormatter = (view: DebugView, viewportIndex: number) => DebugViewportLabel;
+export type DebugViewportLabels = readonly DebugViewportLabel[] | DebugViewportLabelFormatter;
+export declare function createDebugViewportLabels(views: readonly DebugView[], layout: ResolvedDebugViewLayout, labels?: DebugViewportLabels): string[];
+export declare function createDebugViewportPlanLabels(plan: DebugViewportPlan, labels?: DebugViewportLabels): string[];

package/dist/types/debug-viewport-plan.d.ts

@@ -0,0 +1,29 @@
+import type { Camera } from "three";
+import type { DebugView, DebugViewSource } from "./debug-views-tsl/compositor";
+import { type DebugViewLayout, type ResolvedDebugViewLayout } from "./debug-view-layout";
+export type DebugViewsMode = "compose" | "viewport";
+export type DebugViewportResolutionScale = 1 | 0.5 | 0.25;
+export interface DebugViewportView {
+    view: number | DebugViewSource | DebugView;
+    label?: string;
+    camera?: Camera;
+    resolutionScale?: number;
+}
+export interface DebugViewportCell {
+    index: number;
+    view: DebugView;
+    camera?: Camera;
+    resolutionScale: DebugViewportResolutionScale;
+}
+export interface DebugViewportPlan {
+    layout: ResolvedDebugViewLayout;
+    views: DebugView[];
+    cells: DebugViewportCell[];
+}
+export interface DebugViewportPlanOptions {
+    views: readonly DebugView[];
+    viewportViews?: readonly DebugViewportView[];
+    activeView?: number;
+    layout?: DebugViewLayout | ResolvedDebugViewLayout;
+}
+export declare function createDebugViewportPlan({ views, viewportViews, activeView, layout, }: DebugViewportPlanOptions): DebugViewportPlan;

package/dist/types/debug-viewport-presenter.d.ts

@@ -0,0 +1,28 @@
+import type { DebugViewportPlan } from "./debug-viewport-plan";
+export interface DebugViewportNormalizedRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface DebugViewportCssCell {
+    column: number;
+    row: number;
+}
+export interface DebugViewportRect {
+    index: number;
+    css: DebugViewportCssCell;
+    scissor: DebugViewportNormalizedRect;
+}
+export declare function createDebugViewportRects(plan: DebugViewportPlan): DebugViewportRect[];
+export interface DebugViewportDrawingBufferSize {
+    width: number;
+    height: number;
+}
+export interface DebugViewportPixelRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function toDebugViewportPixels(rect: DebugViewportNormalizedRect, drawingBufferSize: DebugViewportDrawingBufferSize): DebugViewportPixelRect;

package/dist/types/debug-views-post.d.ts

@@ -0,0 +1,19 @@
+import { type DebugView } from "./debug-views-tsl/compositor";
+import { type DebugViewLayout } from "./debug-view-layout";
+import { type DebugViewportLabels } from "./debug-viewport-labels";
+import { type DebugViewportView, type DebugViewsMode } from "./debug-viewport-plan";
+export interface DebugViewsProps {
+    views: DebugView[];
+    mode?: DebugViewsMode;
+    viewportViews?: DebugViewportView[];
+    activeView?: number;
+    layout?: DebugViewLayout;
+    slots?: number;
+    columns?: number;
+    rows?: number;
+    showLabels?: boolean;
+    viewportLabels?: DebugViewportLabels;
+    overlayOpacity?: number;
+    enabled?: boolean;
+}
+export declare function DebugViews({ views, mode, viewportViews, activeView, layout, slots, columns, rows, showLabels, viewportLabels, overlayOpacity, enabled, }: DebugViewsProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/debug-views-tsl/ao-fallbacks.d.ts

@@ -0,0 +1,6 @@
+import { type Scene } from "three";
+export declare function createAoFallbacks(scene: Scene): {
+    apply: () => void;
+    refresh: () => void;
+    restore: () => void;
+};

package/dist/types/debug-views-tsl/compositor.d.ts

@@ -0,0 +1,20 @@
+import type { DebugNode, Vec4Node } from "./node-types";
+import type { DebugViewUniforms } from "./uniforms";
+import { type DebugViewLayout, type ResolvedDebugViewLayout } from "../debug-view-layout";
+export type ViewMode = "passthrough" | "normal" | "depth" | "heatmap";
+export type DebugViewSource = "beauty" | "normal" | "materialNormal" | "normalMap" | "depth" | "albedo" | "baseColor" | "roughness" | "metalness" | "metallic" | "opacity" | "transparency" | "ao" | "emissive" | "wireframe" | "lightingOnly" | "reflectionOnly" | "shaderCost";
+export interface DebugView {
+    id?: string;
+    label: string;
+    node?: DebugNode;
+    mode?: ViewMode;
+    source?: DebugViewSource;
+    scale?: number;
+    bias?: number;
+}
+export interface ViewCompositorConfig {
+    views: DebugView[];
+    uniforms: DebugViewUniforms;
+    layout?: DebugViewLayout | ResolvedDebugViewLayout;
+}
+export declare function createViewCompositor(config: ViewCompositorConfig): Vec4Node;

package/dist/types/debug-views-tsl/default-debug-nodes.d.ts

@@ -0,0 +1,35 @@
+import { mrt } from "three/tsl";
+import type { DebugNode, FloatNode } from "./node-types";
+interface DebugPass {
+    getTextureNode(name?: string): DebugNode;
+    getViewZNode(name?: string): FloatNode;
+}
+interface ConfigurableDebugPass extends DebugPass {
+    setMRT(mrtNode: ReturnType<typeof mrt>): unknown;
+}
+export interface MaterialDebugChannels {
+    roughness?: boolean;
+    metalness?: boolean;
+    ao?: boolean;
+    opacity?: boolean;
+}
+export interface SceneDebugOutputs {
+    normal?: boolean;
+    albedo?: boolean;
+    material?: MaterialDebugChannels;
+}
+export interface MaterialDetailOutputs {
+    materialNormal?: boolean;
+    emissive?: boolean;
+}
+interface DefaultDebugNodeResolverOptions {
+    materialDetailPass?: DebugPass;
+    wireframePass?: DebugPass;
+    lightingOnlyPass?: DebugPass;
+    reflectionOnlyPass?: DebugPass;
+    shaderCostPass?: DebugPass;
+}
+export declare function configureSceneDebugPass(scenePass: ConfigurableDebugPass, outputs: SceneDebugOutputs): void;
+export declare function configureMaterialDetailPass(materialDetailPass: ConfigurableDebugPass, outputs: MaterialDetailOutputs): void;
+export declare function createDefaultDebugNodeResolver(scenePass: DebugPass, options?: DefaultDebugNodeResolverOptions): (source: string) => DebugNode;
+export {};

package/dist/types/debug-views-tsl/node-types.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from "three/webgpu";
+export type DebugNode = Node;
+export type FloatNode = Node<"float">;
+export type Vec2Node = Node<"vec2">;
+export type Vec3Node = Node<"vec3">;
+export type Vec4Node = Node<"vec4">;

package/dist/types/debug-views-tsl/uniforms.d.ts

@@ -0,0 +1,12 @@
+import { type DebugViewLayout } from "../debug-view-layout";
+export type { DebugViewLayout, LayoutMode } from "../debug-view-layout";
+export declare function createDebugViewUniforms(): {
+    activeView: import("three/webgpu").UniformNode<"float", number>;
+    layout: import("three/webgpu").UniformNode<"float", number>;
+    viewCount: import("three/webgpu").UniformNode<"float", number>;
+    gridColumns: import("three/webgpu").UniformNode<"float", number>;
+    gridRows: import("three/webgpu").UniformNode<"float", number>;
+    overlayOpacity: import("three/webgpu").UniformNode<"float", number>;
+};
+export type DebugViewUniforms = ReturnType<typeof createDebugViewUniforms>;
+export declare function updateDebugViewUniforms(uniforms: DebugViewUniforms, activeView: number, layout?: DebugViewLayout, viewCount?: number, overlayOpacity?: number): void;

package/dist/types/debug-views-tsl/visualize.d.ts

@@ -0,0 +1,5 @@
+import type { FloatNode, Vec3Node, Vec4Node } from "./node-types";
+export declare function visualizeNormal(normalNode: Vec3Node | Vec4Node): Vec4Node;
+export declare function visualizeGrayscale(floatNode: FloatNode, scale?: import("three/webgpu").VarNode<"float", import("three/webgpu").ConstNode<"float", number>>, bias?: import("three/webgpu").VarNode<"float", import("three/webgpu").ConstNode<"float", number>>): Vec4Node;
+export declare function visualizeDepth(viewDepthNode: FloatNode, scale?: import("three/webgpu").VarNode<"float", import("three/webgpu").ConstNode<"float", number>>, bias?: import("three/webgpu").VarNode<"float", import("three/webgpu").ConstNode<"float", number>>): Vec4Node;
+export declare function visualizeHeatmap(costNode: FloatNode, scale?: import("three/webgpu").VarNode<"float", import("three/webgpu").ConstNode<"float", number>>, bias?: import("three/webgpu").VarNode<"float", import("three/webgpu").ConstNode<"float", number>>): Vec4Node;

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+export { DEFAULT_DEBUG_VIEWS, MATERIAL_DEBUG_VIEW_SOURCES, getDebugViewLabels, } from "./debug-view-definitions";
+export { createCustomDebugView, type CustomDebugNodeViewOptions, } from "./custom-debug-view";
+export { isResolvedDebugViewLayout, LAYOUT_INDEX, resolveDebugViewLayout, type DebugViewLayout, type DebugViewLayoutConfig, type DebugViewLayoutOptions, type LayoutMode, type LayoutPresentation, type ResolvedDebugViewLayout, } from "./debug-view-layout";
+export { createDebugViewportPlan, type DebugViewportCell, type DebugViewportPlan, type DebugViewportPlanOptions, type DebugViewportResolutionScale, type DebugViewportView, type DebugViewsMode, } from "./debug-viewport-plan";
+export { createDebugViewportRenderGraphPlan, type DebugViewportRenderGraphCell, type DebugViewportRenderGraphPlan, type DebugViewportRenderPassPlan, } from "./debug-render-graph-plan";
+export { createDebugViewportRects, type DebugViewportCssCell, type DebugViewportNormalizedRect, type DebugViewportRect, } from "./debug-viewport-presenter";
+export { createDebugViewportLabels, createDebugViewportPlanLabels, type DebugViewportLabel, type DebugViewportLabelFormatter, type DebugViewportLabels, } from "./debug-viewport-labels";
+export { createViewCompositor, type DebugView, type DebugViewSource, type ViewCompositorConfig, type ViewMode, } from "./debug-views-tsl/compositor";
+export { createDebugViewUniforms, updateDebugViewUniforms, type DebugViewUniforms, } from "./debug-views-tsl/uniforms";
+export { visualizeDepth, visualizeGrayscale, visualizeHeatmap, visualizeNormal, } from "./debug-views-tsl/visualize";
+export type { DebugNode, FloatNode, Vec2Node, Vec3Node, Vec4Node, } from "./debug-views-tsl/node-types";

package/dist/types/react.d.ts

@@ -0,0 +1,2 @@
+export { DebugViews, type DebugViewsProps } from "./debug-views-post";
+export { useDebugViewsControls } from "./use-debug-views-controls";

package/dist/types/shader-cost/cost-override.d.ts

@@ -0,0 +1,20 @@
+import { MeshBasicMaterial, Object3D, type Scene } from "three";
+import { type MaterialCostCache } from "./material-cost";
+export declare const DEFAULT_SHADER_COST_BUCKET_COUNT = 16;
+export interface ShaderCostOverrideOptions {
+    bucketCount?: number;
+    cache?: MaterialCostCache;
+}
+export interface ShaderCostOverride {
+    apply(scene: Scene | Object3D): ShaderCostRestore;
+    dispose(): void;
+    readonly bucketCount: number;
+    readonly materials: readonly MeshBasicMaterial[];
+}
+export interface ShaderCostRestore {
+    restore(): void;
+    readonly replacements: number;
+}
+export declare function createShaderCostOverride(options?: ShaderCostOverrideOptions): ShaderCostOverride;
+export declare function createShaderCostBucketMaterials(bucketCount?: number): MeshBasicMaterial[];
+export declare function getShaderCostBucketIndex(cost: number, bucketCount?: number): number;