material-designer-runtime 0.1.3 → 0.1.4

package/dist/graph/bake-service.d.ts

@@ -1,6 +1,7 @@
 import * as THREE from "three";
 import { RenderTarget, type WebGPURenderer, type MeshBasicNodeMaterial } from "three/webgpu";
 import { type CacheEntry, type ParamUsage } from "./compiler";
+import { type NodeProfileOptions, type NodeProfileReport } from "./node-profiler";
 import type { MaterialGraphSource, MaterialValue, PbrSocket } from "./types";
 export declare const SURFACE_CHANNELS: PbrSocket[];
 export interface BakeOptions {
@@ -46,6 +47,7 @@ export declare class BakedTextureSet {
     ensureHeightTarget(): RenderTarget;
     texture(ch: PbrSocket): THREE.Texture | null;
     allocConstantArray(nodeId: string, key: string, data: ArrayLike<number>, elementType: "float" | "vec3"): MaterialValue;
+    debugCounts(): Record<string, number>;
     flushCaches(): void;
     dispose(): void;
 }
@@ -82,7 +84,9 @@ export declare class MaterialBakeService {
     rerenderInto(set: BakedTextureSet, source?: string): Promise<void>;
     bake(graph: MaterialGraphSource, opts?: BakeOptions): Promise<BakedTextureSet>;
     readImage(graph: MaterialGraphSource, channel: PbrSocket, size?: number): Promise<ImageData | null>;
+    gpuInfo(): Record<string, unknown>;
     private scratchTarget;
+    profileNodes(graph: MaterialGraphSource, opts?: NodeProfileOptions): Promise<NodeProfileReport>;
     private scratchCache;
 }
 export declare const bakeService: MaterialBakeService;

package/dist/graph/channel-baker.d.ts

@@ -3,6 +3,7 @@ import type { MaterialValue, PbrSocket } from "./types";
 export declare const FIELD_CHANNELS: PbrSocket[];
 export declare const COLOR_CHANNELS: PbrSocket[];
 export declare function encodeChannel(node: MaterialValue, channel: PbrSocket): MaterialValue;
+export declare function ssPoolInfo(): string[];
 export declare function makeChannelMaterial(): MeshBasicNodeMaterial;
 export declare function compileMaterialsAsync(renderer: WebGPURenderer, materials: MeshBasicNodeMaterial[], destSize: number): Promise<void>;
 export declare function renderCacheToTarget(renderer: WebGPURenderer, material: MeshBasicNodeMaterial, rt: RenderTarget): void;

package/dist/graph/node-profiler.d.ts

@@ -0,0 +1,25 @@
+import type { MaterialGraphDocument, GraphNode } from "./types";
+import type { NodeRegistry } from "./registry";
+export interface NodeProfileOptions {
+    nodeIds?: string[];
+    size?: number;
+    runs?: number;
+}
+export interface NodeProfileRow {
+    nodeId: string;
+    type: string;
+    label?: string;
+    pipelineMs: number;
+    renderMs: number;
+    marginalMs: number;
+    error?: string;
+}
+export interface NodeProfileReport {
+    size: number;
+    runs: number;
+    overheadMs: number;
+    nodes: NodeProfileRow[];
+}
+export declare function profilableNodes(doc: MaterialGraphDocument, registry: NodeRegistry, only?: string[]): GraphNode[];
+export declare function median(samples: number[]): number;
+export declare function deriveMarginals(rows: NodeProfileRow[], doc: MaterialGraphDocument, overheadMs: number): void;

package/dist/graph/textured-surface.d.ts

@@ -13,9 +13,6 @@ export declare class TexturedSurface {
     private material_;
     readonly scaleUniform: import("three/webgpu").UniformNode<"float", number>;
     readonly sharpnessUniform: import("three/webgpu").UniformNode<"float", number>;
-    readonly roughnessFactor: import("three/webgpu").UniformNode<"float", number>;
-    readonly metalnessFactor: import("three/webgpu").UniformNode<"float", number>;
-    readonly colorTint: import("three/webgpu").UniformNode<"color", THREE.Color>;
     readonly parallaxScale: import("three/webgpu").UniformNode<"float", number>;
     lastBakeMs: number;
     private set;
@@ -50,11 +47,9 @@ export declare class TexturedSurface {
     refresh(): Promise<void>;
     releaseCaches(): Promise<void>;
     regenerate(): void;
+    debugReport(): Record<string, unknown>;
     setScale(value: number): void;
     setSharpness(value: number): void;
-    setRoughnessFactor(value: number): void;
-    setMetalnessFactor(value: number): void;
-    setColorTint(hex: string): void;
     setParallaxScale(value: number): void;
     setTriplanar(on: boolean): void;
     setNormalDebug(on: boolean): void;

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { MaterialGraphRuntime, type MaterialGraphRuntimeOptions } from "./runtim
 export { MATERIAL_DOCUMENT_VERSION, MaterialGraphSession, cloneMaterialDocument, createDefaultMaterialDocument, migrateMaterialDocument, } from "./document";
 export { createMaterialTopologyKey } from "./topology";
 export { MaterialBakeService, BakedTextureSet, SURFACE_CHANNELS, bakeService, type BakeOptions, type BakeReport, } from "./graph/bake-service";
+export { type NodeProfileOptions, type NodeProfileReport, type NodeProfileRow, } from "./graph/node-profiler";
 export { compileGraph, compileSockets, countGraphNodes, newSurfaceMaterial, readMaterialSurface, readMaterialConfig, readOutputResolution, type CompileOptions, type CompiledSockets, type MaterialConfig, } from "./graph/compiler";
 export { buildMeshMaterial, type ChannelTextures } from "./graph/mesh-material";
 export { NodeRegistry, createDefaultRegistry, defaultRegistry, nodeParamDefs, nodePorts, } from "./graph/registry";