@nice2dev/ui-3d 1.0.0 → 1.0.2

package/dist/cjs/material/materialEditorUtils.js

@@ -0,0 +1,841 @@
+'use strict';
+
+var materialNodeDefinitions = require('./materialNodeDefinitions.js');
+
+/* ════════════════════════════════════════════════════════════════════════════
+   Material Editor Utilities
+   
+   Graph operations, shader compilation, and helper functions:
+   - Graph manipulation (add/remove/connect nodes)
+   - Topological sorting for compilation order
+   - GLSL shader generation
+   - Import/export functionality
+   - Validation
+   ════════════════════════════════════════════════════════════════════════════ */
+/* ═══════════════════════════════════════════════════════════════════════════
+   ID Generation
+   ═══════════════════════════════════════════════════════════════════════════ */
+let nodeIdCounter = 0;
+let connectionIdCounter = 0;
+function generateNodeId() {
+    return `node_${Date.now()}_${++nodeIdCounter}`;
+}
+function generateConnectionId() {
+    return `conn_${Date.now()}_${++connectionIdCounter}`;
+}
+function resetIdCounters() {
+    nodeIdCounter = 0;
+    connectionIdCounter = 0;
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   Graph Creation
+   ═══════════════════════════════════════════════════════════════════════════ */
+function createEmptyGraph(name = 'New Material') {
+    const outputNode = {
+        id: generateNodeId(),
+        type: 'output_pbr',
+        position: { x: 400, y: 200 },
+        properties: {},
+        inputValues: {},
+    };
+    return {
+        id: `graph_${Date.now()}`,
+        name,
+        nodes: [outputNode],
+        connections: [],
+        outputNodeId: outputNode.id,
+        metadata: {
+            createdAt: new Date(),
+            modifiedAt: new Date(),
+            blendMode: 'opaque',
+            cullMode: 'back',
+            depthTest: true,
+            depthWrite: true,
+        },
+    };
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   Node Operations
+   ═══════════════════════════════════════════════════════════════════════════ */
+function createNode(type, position, definitions = materialNodeDefinitions.MATERIAL_NODE_MAP) {
+    var _a;
+    const definition = definitions.get(type);
+    if (!definition)
+        return null;
+    const properties = {};
+    const inputValues = {};
+    // Initialize properties with defaults
+    (_a = definition.properties) === null || _a === void 0 ? void 0 : _a.forEach(prop => {
+        properties[prop.id] = prop.default;
+    });
+    // Initialize input values with defaults
+    definition.inputs.forEach(input => {
+        if (input.defaultValue !== undefined) {
+            inputValues[input.id] = input.defaultValue;
+        }
+    });
+    return {
+        id: generateNodeId(),
+        type,
+        position: { ...position },
+        properties,
+        inputValues,
+    };
+}
+function cloneNode(node) {
+    return {
+        ...node,
+        id: generateNodeId(),
+        position: { x: node.position.x + 20, y: node.position.y + 20 },
+        properties: { ...node.properties },
+        inputValues: { ...node.inputValues },
+        selected: false,
+    };
+}
+function getNodeDefinition(node, definitions = materialNodeDefinitions.MATERIAL_NODE_MAP) {
+    return definitions.get(node.type);
+}
+function getNodeBounds(node, definition) {
+    const nodeWidth = 180;
+    const headerHeight = 32;
+    const portHeight = 24;
+    const maxPorts = Math.max(definition.inputs.length, definition.outputs.length);
+    const nodeHeight = headerHeight + maxPorts * portHeight + 8;
+    return {
+        x: node.position.x,
+        y: node.position.y,
+        width: nodeWidth,
+        height: nodeHeight,
+    };
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   Connection Operations
+   ═══════════════════════════════════════════════════════════════════════════ */
+function createConnection(sourceNodeId, sourcePortId, targetNodeId, targetPortId) {
+    return {
+        id: generateConnectionId(),
+        sourceNodeId,
+        sourcePortId,
+        targetNodeId,
+        targetPortId,
+    };
+}
+function canConnect(sourceNode, sourcePort, targetNode, targetPort, existingConnections) {
+    // Can't connect to self
+    if (sourceNode.id === targetNode.id) {
+        return { valid: false, reason: 'Cannot connect node to itself' };
+    }
+    // Check port directions
+    if (sourcePort.direction !== 'output' || targetPort.direction !== 'input') {
+        return { valid: false, reason: 'Invalid port direction' };
+    }
+    // Check if target port already has a connection
+    const existingConnection = existingConnections.find(conn => conn.targetNodeId === targetNode.id && conn.targetPortId === targetPort.id);
+    if (existingConnection) {
+        return { valid: false, reason: 'Port already connected' };
+    }
+    // Check type compatibility
+    if (!areTypesCompatible(sourcePort.dataType, targetPort.dataType)) {
+        return { valid: false, reason: `Incompatible types: ${sourcePort.dataType} → ${targetPort.dataType}` };
+    }
+    return { valid: true };
+}
+function areTypesCompatible(sourceType, targetType) {
+    // 'any' type is compatible with everything
+    if (sourceType === 'any' || targetType === 'any')
+        return true;
+    // Same types are compatible
+    if (sourceType === targetType)
+        return true;
+    // Float can be used where vec2/vec3/vec4 is expected (broadcast)
+    if (sourceType === 'float' && ['vec2', 'vec3', 'vec4'].includes(targetType))
+        return true;
+    // Color is compatible with vec3/vec4
+    if (sourceType === 'color' && ['vec3', 'vec4'].includes(targetType))
+        return true;
+    if (sourceType === 'vec3' && targetType === 'color')
+        return true;
+    return false;
+}
+function getPortConnections(nodeId, portId, direction, connections) {
+    if (direction === 'input') {
+        return connections.filter(conn => conn.targetNodeId === nodeId && conn.targetPortId === portId);
+    }
+    return connections.filter(conn => conn.sourceNodeId === nodeId && conn.sourcePortId === portId);
+}
+function getNodeConnections(nodeId, connections) {
+    return connections.filter(conn => conn.sourceNodeId === nodeId || conn.targetNodeId === nodeId);
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   Graph Operations
+   ═══════════════════════════════════════════════════════════════════════════ */
+function addNodeToGraph(graph, node) {
+    return {
+        ...graph,
+        nodes: [...graph.nodes, node],
+        metadata: { ...graph.metadata, modifiedAt: new Date() },
+    };
+}
+function removeNodesFromGraph(graph, nodeIds) {
+    const nodeIdSet = new Set(nodeIds);
+    // Don't remove the output node
+    if (nodeIdSet.has(graph.outputNodeId)) {
+        nodeIdSet.delete(graph.outputNodeId);
+    }
+    return {
+        ...graph,
+        nodes: graph.nodes.filter(node => !nodeIdSet.has(node.id)),
+        connections: graph.connections.filter(conn => !nodeIdSet.has(conn.sourceNodeId) && !nodeIdSet.has(conn.targetNodeId)),
+        metadata: { ...graph.metadata, modifiedAt: new Date() },
+    };
+}
+function addConnectionToGraph(graph, connection) {
+    // Remove existing connection to target port
+    const filteredConnections = graph.connections.filter(conn => !(conn.targetNodeId === connection.targetNodeId && conn.targetPortId === connection.targetPortId));
+    return {
+        ...graph,
+        connections: [...filteredConnections, connection],
+        metadata: { ...graph.metadata, modifiedAt: new Date() },
+    };
+}
+function removeConnectionFromGraph(graph, connectionId) {
+    return {
+        ...graph,
+        connections: graph.connections.filter(conn => conn.id !== connectionId),
+        metadata: { ...graph.metadata, modifiedAt: new Date() },
+    };
+}
+function updateNodeInGraph(graph, nodeId, updates) {
+    return {
+        ...graph,
+        nodes: graph.nodes.map(node => node.id === nodeId ? { ...node, ...updates } : node),
+        metadata: { ...graph.metadata, modifiedAt: new Date() },
+    };
+}
+function moveNodesInGraph(graph, nodeIds, delta) {
+    const nodeIdSet = new Set(nodeIds);
+    return {
+        ...graph,
+        nodes: graph.nodes.map(node => nodeIdSet.has(node.id)
+            ? { ...node, position: { x: node.position.x + delta.x, y: node.position.y + delta.y } }
+            : node),
+    };
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   Topological Sort
+   ═══════════════════════════════════════════════════════════════════════════ */
+function topologicalSort(graph) {
+    const sorted = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const nodeMap = new Map(graph.nodes.map(n => [n.id, n]));
+    function visit(nodeId) {
+        if (visited.has(nodeId))
+            return true;
+        if (visiting.has(nodeId))
+            return false; // Cycle detected
+        visiting.add(nodeId);
+        // Find all nodes that this node depends on (inputs)
+        const inputConnections = graph.connections.filter(conn => conn.targetNodeId === nodeId);
+        for (const conn of inputConnections) {
+            if (!visit(conn.sourceNodeId)) {
+                return false; // Cycle
+            }
+        }
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+        const node = nodeMap.get(nodeId);
+        if (node) {
+            sorted.push(node);
+        }
+        return true;
+    }
+    // Start from output node and work backwards
+    visit(graph.outputNodeId);
+    // Visit any unvisited nodes (disconnected)
+    for (const node of graph.nodes) {
+        if (!visited.has(node.id)) {
+            visit(node.id);
+        }
+    }
+    return sorted;
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   Shader Compilation
+   ═══════════════════════════════════════════════════════════════════════════ */
+function compileShader(graph, definitions = materialNodeDefinitions.MATERIAL_NODE_MAP) {
+    const errors = [];
+    const warnings = [];
+    const uniforms = [];
+    const fragmentLines = [];
+    // Validate graph
+    const validationResult = validateGraph(graph, definitions);
+    errors.push(...validationResult.errors);
+    warnings.push(...validationResult.warnings);
+    if (errors.length > 0) {
+        return {
+            vertexShader: generateDefaultVertexShader(),
+            fragmentShader: generateErrorFragmentShader(errors),
+            uniforms,
+            attributes: [],
+            defines: {},
+            errors,
+            warnings,
+        };
+    }
+    // Sort nodes topologically
+    const sortedNodes = topologicalSort(graph);
+    // Generate code for each node
+    const nodeOutputs = new Map();
+    for (const node of sortedNodes) {
+        const definition = definitions.get(node.type);
+        if (!definition)
+            continue;
+        const nodeCode = generateNodeCode(node, definition, graph, nodeOutputs);
+        if (nodeCode) {
+            fragmentLines.push(`  // ${definition.name}`);
+            fragmentLines.push(nodeCode);
+            fragmentLines.push('');
+        }
+    }
+    // Generate final fragment shader
+    const fragmentShader = generateFragmentShader(graph, fragmentLines, definitions);
+    return {
+        vertexShader: generateDefaultVertexShader(),
+        fragmentShader,
+        uniforms,
+        attributes: [
+            { name: 'position', type: 'vec3', location: 0 },
+            { name: 'normal', type: 'vec3', location: 1 },
+            { name: 'uv', type: 'vec2', location: 2 },
+        ],
+        defines: {},
+        errors,
+        warnings,
+    };
+}
+function generateNodeCode(node, definition, graph, nodeOutputs, uniforms) {
+    var _a;
+    const outputs = new Map();
+    const lines = [];
+    // Get input values (either from connections or defaults)
+    const inputValues = {};
+    for (const input of definition.inputs) {
+        const connection = graph.connections.find(conn => conn.targetNodeId === node.id && conn.targetPortId === input.id);
+        if (connection) {
+            const sourceOutputs = nodeOutputs.get(connection.sourceNodeId);
+            inputValues[input.id] = (sourceOutputs === null || sourceOutputs === void 0 ? void 0 : sourceOutputs.get(connection.sourcePortId)) || '0.0';
+        }
+        else {
+            inputValues[input.id] = formatDefaultValue((_a = node.inputValues[input.id]) !== null && _a !== void 0 ? _a : input.defaultValue, input.dataType);
+        }
+    }
+    // Generate output variable names
+    for (const output of definition.outputs) {
+        const varName = `${node.id}_${output.id}`;
+        outputs.set(output.id, varName);
+    }
+    // Store outputs for downstream nodes
+    nodeOutputs.set(node.id, outputs);
+    // Generate GLSL code based on node type
+    const code = generateGLSLForNode(node, definition, inputValues);
+    if (code) {
+        lines.push(code);
+    }
+    return lines.join('\n');
+}
+function generateGLSLForNode(node, definition, inputs, outputs, uniforms) {
+    var _a, _b;
+    const nodeId = node.id.replace(/-/g, '_');
+    switch (definition.type) {
+        // Input nodes
+        case 'constant_float':
+            return `  float ${nodeId}_value = ${(_b = (_a = node.properties.value) === null || _a === void 0 ? void 0 : _a.toFixed(4)) !== null && _b !== void 0 ? _b : '0.0'};`;
+        case 'constant_color': {
+            const color = parseColor(node.properties.color || '#ffffff');
+            return `  vec3 ${nodeId}_rgb = vec3(${color.r.toFixed(4)}, ${color.g.toFixed(4)}, ${color.b.toFixed(4)});
+  vec4 ${nodeId}_rgba = vec4(${nodeId}_rgb, 1.0);
+  float ${nodeId}_r = ${nodeId}_rgb.r;
+  float ${nodeId}_g = ${nodeId}_rgb.g;
+  float ${nodeId}_b = ${nodeId}_rgb.b;
+  float ${nodeId}_a = 1.0;`;
+        }
+        case 'uv':
+            return `  vec2 ${nodeId}_uv = vUv;
+  float ${nodeId}_u = vUv.x;
+  float ${nodeId}_v = vUv.y;`;
+        case 'time':
+            return `  float ${nodeId}_time = uTime;
+  float ${nodeId}_sin = sin(uTime);
+  float ${nodeId}_cos = cos(uTime);
+  float ${nodeId}_delta = uDeltaTime;`;
+        case 'position':
+            return `  vec3 ${nodeId}_world = vWorldPosition;
+  vec3 ${nodeId}_object = vPosition;
+  vec3 ${nodeId}_view = vViewPosition;`;
+        case 'normal':
+            return `  vec3 ${nodeId}_world = normalize(vWorldNormal);
+  vec3 ${nodeId}_object = normalize(vNormal);
+  vec3 ${nodeId}_view = normalize(vViewNormal);
+  vec3 ${nodeId}_tangent = normalize(vTangent);
+  vec3 ${nodeId}_bitangent = normalize(vBitangent);`;
+        // Math nodes
+        case 'add':
+            return `  ${getTypeForAny(inputs.a)} ${nodeId}_result = ${inputs.a} + ${inputs.b};`;
+        case 'subtract':
+            return `  ${getTypeForAny(inputs.a)} ${nodeId}_result = ${inputs.a} - ${inputs.b};`;
+        case 'multiply':
+            return `  ${getTypeForAny(inputs.a)} ${nodeId}_result = ${inputs.a} * ${inputs.b};`;
+        case 'divide':
+            return `  ${getTypeForAny(inputs.a)} ${nodeId}_result = ${inputs.a} / max(${inputs.b}, 0.0001);`;
+        case 'sin':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = sin(${inputs.value});`;
+        case 'cos':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = cos(${inputs.value});`;
+        case 'abs':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = abs(${inputs.value});`;
+        case 'floor':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = floor(${inputs.value});`;
+        case 'fract':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = fract(${inputs.value});`;
+        case 'min':
+            return `  ${getTypeForAny(inputs.a)} ${nodeId}_result = min(${inputs.a}, ${inputs.b});`;
+        case 'max':
+            return `  ${getTypeForAny(inputs.a)} ${nodeId}_result = max(${inputs.a}, ${inputs.b});`;
+        // Vector nodes
+        case 'combine_vec2':
+            return `  vec2 ${nodeId}_vector = vec2(${inputs.x}, ${inputs.y});`;
+        case 'combine_vec3':
+            return `  vec3 ${nodeId}_vector = vec3(${inputs.x}, ${inputs.y}, ${inputs.z});`;
+        case 'combine_vec4':
+            return `  vec4 ${nodeId}_vector = vec4(${inputs.x}, ${inputs.y}, ${inputs.z}, ${inputs.w});`;
+        case 'split_vec3':
+            return `  float ${nodeId}_x = ${inputs.vector}.x;
+  float ${nodeId}_y = ${inputs.vector}.y;
+  float ${nodeId}_z = ${inputs.vector}.z;`;
+        case 'normalize':
+            return `  vec3 ${nodeId}_result = normalize(${inputs.vector});`;
+        case 'dot':
+            return `  float ${nodeId}_result = dot(${inputs.a}, ${inputs.b});`;
+        case 'cross':
+            return `  vec3 ${nodeId}_result = cross(${inputs.a}, ${inputs.b});`;
+        // Utility nodes
+        case 'lerp':
+            return `  ${getTypeForAny(inputs.a)} ${nodeId}_result = mix(${inputs.a}, ${inputs.b}, ${inputs.t});`;
+        case 'clamp':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = clamp(${inputs.value}, ${inputs.min}, ${inputs.max});`;
+        case 'saturate':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = clamp(${inputs.value}, 0.0, 1.0);`;
+        case 'smoothstep':
+            return `  float ${nodeId}_result = smoothstep(${inputs.edge0}, ${inputs.edge1}, ${inputs.x});`;
+        case 'one_minus':
+            return `  ${getTypeForAny(inputs.value)} ${nodeId}_result = 1.0 - ${inputs.value};`;
+        case 'fresnel':
+            return `  float ${nodeId}_result = pow(1.0 - max(dot(${inputs.normal}, ${inputs.viewDir}), 0.0), ${inputs.power});`;
+        // Procedural nodes
+        case 'noise_perlin':
+            return `  float ${nodeId}_value = perlinNoise(${inputs.uv} * ${inputs.scale});`;
+        case 'checker':
+            return `  float ${nodeId}_value = mod(floor(${inputs.uv}.x * ${inputs.scale}) + floor(${inputs.uv}.y * ${inputs.scale}), 2.0);
+  vec3 ${nodeId}_color = mix(${inputs.colorA}, ${inputs.colorB}, ${nodeId}_value);`;
+        case 'gradient_linear':
+            const dir = node.properties.direction || 'horizontal';
+            const gradientCoord = dir === 'horizontal' ? 'x' : dir === 'vertical' ? 'y' : '(x + y) * 0.5';
+            return `  float ${nodeId}_value = ${inputs.uv}.${gradientCoord === '(x + y) * 0.5' ? gradientCoord : gradientCoord};`;
+        case 'gradient_radial':
+            return `  float ${nodeId}_value = 1.0 - clamp(distance(${inputs.uv}, ${inputs.center}) / ${inputs.radius}, 0.0, 1.0);`;
+        // Color nodes
+        case 'invert':
+            return `  vec3 ${nodeId}_result = vec3(1.0) - ${inputs.color};`;
+        case 'grayscale':
+            return `  float ${nodeId}_gray = dot(${inputs.color}, vec3(0.299, 0.587, 0.114));
+  vec3 ${nodeId}_rgb = vec3(${nodeId}_gray);`;
+        case 'blend': {
+            const mode = node.properties.mode || 'normal';
+            const blendCode = generateBlendMode(mode, inputs.base, inputs.blend);
+            return `  vec3 ${nodeId}_result = mix(${inputs.base}, ${blendCode}, ${inputs.factor});`;
+        }
+        default:
+            return `  // Unsupported node type: ${definition.type}`;
+    }
+}
+function generateBlendMode(mode, base, blend) {
+    switch (mode) {
+        case 'multiply':
+            return `${base} * ${blend}`;
+        case 'screen':
+            return `1.0 - (1.0 - ${base}) * (1.0 - ${blend})`;
+        case 'overlay':
+            return `mix(2.0 * ${base} * ${blend}, 1.0 - 2.0 * (1.0 - ${base}) * (1.0 - ${blend}), step(0.5, ${base}))`;
+        case 'add':
+            return `min(${base} + ${blend}, vec3(1.0))`;
+        case 'subtract':
+            return `max(${base} - ${blend}, vec3(0.0))`;
+        case 'difference':
+            return `abs(${base} - ${blend})`;
+        default:
+            return blend;
+    }
+}
+function getTypeForAny(value) {
+    if (value.startsWith('vec4'))
+        return 'vec4';
+    if (value.startsWith('vec3'))
+        return 'vec3';
+    if (value.startsWith('vec2'))
+        return 'vec2';
+    return 'float';
+}
+function formatDefaultValue(value, dataType) {
+    if (value === undefined || value === null) {
+        switch (dataType) {
+            case 'float': return '0.0';
+            case 'vec2': return 'vec2(0.0)';
+            case 'vec3': return 'vec3(0.0)';
+            case 'vec4': return 'vec4(0.0)';
+            case 'bool': return 'false';
+            case 'int': return '0';
+            default: return '0.0';
+        }
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 2)
+            return `vec2(${value[0].toFixed(4)}, ${value[1].toFixed(4)})`;
+        if (value.length === 3)
+            return `vec3(${value[0].toFixed(4)}, ${value[1].toFixed(4)}, ${value[2].toFixed(4)})`;
+        if (value.length === 4)
+            return `vec4(${value[0].toFixed(4)}, ${value[1].toFixed(4)}, ${value[2].toFixed(4)}, ${value[3].toFixed(4)})`;
+    }
+    if (typeof value === 'number') {
+        return value.toFixed(4);
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    return String(value);
+}
+function parseColor(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16) / 255,
+            g: parseInt(result[2], 16) / 255,
+            b: parseInt(result[3], 16) / 255,
+        }
+        : { r: 1, g: 1, b: 1 };
+}
+function generateDefaultVertexShader() {
+    return `#version 300 es
+precision highp float;
+
+in vec3 position;
+in vec3 normal;
+in vec2 uv;
+in vec3 tangent;
+
+uniform mat4 modelMatrix;
+uniform mat4 viewMatrix;
+uniform mat4 projectionMatrix;
+uniform mat3 normalMatrix;
+
+out vec3 vPosition;
+out vec3 vNormal;
+out vec2 vUv;
+out vec3 vWorldPosition;
+out vec3 vWorldNormal;
+out vec3 vViewPosition;
+out vec3 vViewNormal;
+out vec3 vTangent;
+out vec3 vBitangent;
+
+void main() {
+  vPosition = position;
+  vNormal = normal;
+  vUv = uv;
+  
+  vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+  vWorldPosition = worldPosition.xyz;
+  vWorldNormal = normalMatrix * normal;
+  
+  vec4 viewPosition = viewMatrix * worldPosition;
+  vViewPosition = viewPosition.xyz;
+  vViewNormal = mat3(viewMatrix) * vWorldNormal;
+  
+  vTangent = normalMatrix * tangent;
+  vBitangent = cross(vWorldNormal, vTangent);
+  
+  gl_Position = projectionMatrix * viewPosition;
+}`;
+}
+function generateFragmentShader(graph, nodeCode, definitions) {
+    const outputNode = graph.nodes.find(n => n.id === graph.outputNodeId);
+    outputNode ? definitions.get(outputNode.type) : null;
+    return `#version 300 es
+precision highp float;
+
+in vec3 vPosition;
+in vec3 vNormal;
+in vec2 vUv;
+in vec3 vWorldPosition;
+in vec3 vWorldNormal;
+in vec3 vViewPosition;
+in vec3 vViewNormal;
+in vec3 vTangent;
+in vec3 vBitangent;
+
+uniform float uTime;
+uniform float uDeltaTime;
+uniform vec3 uCameraPosition;
+uniform vec2 uResolution;
+
+out vec4 fragColor;
+
+// Noise functions
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+float perlinNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+void main() {
+${nodeCode.join('\n')}
+
+  // Output
+  ${generateOutputAssignment(graph)}
+}`;
+}
+function generateOutputAssignment(graph, definitions) {
+    const outputNode = graph.nodes.find(n => n.id === graph.outputNodeId);
+    if (!outputNode) {
+        return 'fragColor = vec4(1.0, 0.0, 1.0, 1.0); // Error: no output node';
+    }
+    outputNode.id.replace(/-/g, '_');
+    // Find what's connected to the output
+    const albedoConn = graph.connections.find(c => c.targetNodeId === outputNode.id && c.targetPortId === 'albedo');
+    const colorConn = graph.connections.find(c => c.targetNodeId === outputNode.id && c.targetPortId === 'color');
+    if (outputNode.type === 'output_pbr') {
+        const albedo = albedoConn
+            ? `${albedoConn.sourceNodeId.replace(/-/g, '_')}_${albedoConn.sourcePortId}`
+            : 'vec3(1.0)';
+        return `fragColor = vec4(${albedo}, 1.0);`;
+    }
+    if (outputNode.type === 'output_unlit') {
+        const color = colorConn
+            ? `${colorConn.sourceNodeId.replace(/-/g, '_')}_${colorConn.sourcePortId}`
+            : 'vec3(1.0)';
+        return `fragColor = vec4(${color}, 1.0);`;
+    }
+    return 'fragColor = vec4(1.0);';
+}
+function generateErrorFragmentShader(errors) {
+    return `#version 300 es
+precision highp float;
+
+out vec4 fragColor;
+
+void main() {
+  // Compilation errors: ${errors.length}
+  // ${errors.map(e => e.message).join('\n  // ')}
+  fragColor = vec4(1.0, 0.0, 1.0, 1.0);
+}`;
+}
+function validateGraph(graph, definitions = materialNodeDefinitions.MATERIAL_NODE_MAP) {
+    const errors = [];
+    const warnings = [];
+    // Check for output node
+    if (!graph.outputNodeId) {
+        errors.push({ nodeId: '', message: 'No output node defined' });
+    }
+    const outputNode = graph.nodes.find(n => n.id === graph.outputNodeId);
+    if (!outputNode) {
+        errors.push({ nodeId: graph.outputNodeId, message: 'Output node not found in graph' });
+    }
+    // Validate each node
+    for (const node of graph.nodes) {
+        const definition = definitions.get(node.type);
+        if (!definition) {
+            errors.push({ nodeId: node.id, message: `Unknown node type: ${node.type}` });
+            continue;
+        }
+        // Check required inputs
+        for (const input of definition.inputs) {
+            const hasConnection = graph.connections.some(conn => conn.targetNodeId === node.id && conn.targetPortId === input.id);
+            const hasDefault = input.defaultValue !== undefined || node.inputValues[input.id] !== undefined;
+            if (!hasConnection && !hasDefault) {
+                warnings.push({ nodeId: node.id, message: `Input '${input.name}' is not connected` });
+            }
+        }
+    }
+    // Check for cycles
+    const hasCycle = detectCycle(graph);
+    if (hasCycle) {
+        errors.push({ nodeId: '', message: 'Graph contains a cycle' });
+    }
+    // Check connections
+    for (const conn of graph.connections) {
+        const sourceNode = graph.nodes.find(n => n.id === conn.sourceNodeId);
+        const targetNode = graph.nodes.find(n => n.id === conn.targetNodeId);
+        if (!sourceNode) {
+            errors.push({ nodeId: conn.sourceNodeId, message: 'Source node not found' });
+        }
+        if (!targetNode) {
+            errors.push({ nodeId: conn.targetNodeId, message: 'Target node not found' });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+function detectCycle(graph) {
+    const visited = new Set();
+    const visiting = new Set();
+    function dfs(nodeId) {
+        if (visiting.has(nodeId))
+            return true;
+        if (visited.has(nodeId))
+            return false;
+        visiting.add(nodeId);
+        const outgoingConnections = graph.connections.filter(conn => conn.sourceNodeId === nodeId);
+        for (const conn of outgoingConnections) {
+            if (dfs(conn.targetNodeId))
+                return true;
+        }
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+        return false;
+    }
+    for (const node of graph.nodes) {
+        if (dfs(node.id))
+            return true;
+    }
+    return false;
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   View Utilities
+   ═══════════════════════════════════════════════════════════════════════════ */
+function screenToGraph(screenPoint, viewTransform) {
+    return {
+        x: (screenPoint.x - viewTransform.x) / viewTransform.zoom,
+        y: (screenPoint.y - viewTransform.y) / viewTransform.zoom,
+    };
+}
+function graphToScreen(graphPoint, viewTransform) {
+    return {
+        x: graphPoint.x * viewTransform.zoom + viewTransform.x,
+        y: graphPoint.y * viewTransform.zoom + viewTransform.y,
+    };
+}
+function calculateBoundingBox(nodes) {
+    if (nodes.length === 0)
+        return null;
+    let minX = Infinity, minY = Infinity;
+    let maxX = -Infinity, maxY = -Infinity;
+    for (const node of nodes) {
+        minX = Math.min(minX, node.position.x);
+        minY = Math.min(minY, node.position.y);
+        maxX = Math.max(maxX, node.position.x + 180);
+        maxY = Math.max(maxY, node.position.y + 120);
+    }
+    return {
+        x: minX,
+        y: minY,
+        width: maxX - minX,
+        height: maxY - minY,
+    };
+}
+function calculateZoomToFit(nodes, viewportWidth, viewportHeight, padding = 50) {
+    const bbox = calculateBoundingBox(nodes);
+    if (!bbox) {
+        return { x: 0, y: 0, zoom: 1 };
+    }
+    const scaleX = (viewportWidth - padding * 2) / bbox.width;
+    const scaleY = (viewportHeight - padding * 2) / bbox.height;
+    const zoom = Math.min(scaleX, scaleY, 1);
+    const centerX = bbox.x + bbox.width / 2;
+    const centerY = bbox.y + bbox.height / 2;
+    return {
+        x: viewportWidth / 2 - centerX * zoom,
+        y: viewportHeight / 2 - centerY * zoom,
+        zoom,
+    };
+}
+/* ═══════════════════════════════════════════════════════════════════════════
+   Import/Export
+   ═══════════════════════════════════════════════════════════════════════════ */
+function exportGraphToJSON(graph) {
+    return JSON.stringify(graph, null, 2);
+}
+function importGraphFromJSON(json) {
+    try {
+        const parsed = JSON.parse(json);
+        // Basic validation
+        if (!parsed.id || !parsed.nodes || !parsed.connections) {
+            return null;
+        }
+        return parsed;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function exportToThreeJS(shader) {
+    return `import * as THREE from 'three';
+
+const material = new THREE.ShaderMaterial({
+  uniforms: {
+    uTime: { value: 0 },
+    uDeltaTime: { value: 0 },
+    uCameraPosition: { value: new THREE.Vector3() },
+    uResolution: { value: new THREE.Vector2() },
+${shader.uniforms.map(u => `    ${u.name}: { value: ${JSON.stringify(u.value)} },`).join('\n')}
+  },
+  vertexShader: \`${shader.vertexShader}\`,
+  fragmentShader: \`${shader.fragmentShader}\`,
+});
+
+export default material;`;
+}
+
+exports.addConnectionToGraph = addConnectionToGraph;
+exports.addNodeToGraph = addNodeToGraph;
+exports.areTypesCompatible = areTypesCompatible;
+exports.calculateBoundingBox = calculateBoundingBox;
+exports.calculateZoomToFit = calculateZoomToFit;
+exports.canConnect = canConnect;
+exports.cloneNode = cloneNode;
+exports.compileShader = compileShader;
+exports.createConnection = createConnection;
+exports.createEmptyGraph = createEmptyGraph;
+exports.createNode = createNode;
+exports.exportGraphToJSON = exportGraphToJSON;
+exports.exportToThreeJS = exportToThreeJS;
+exports.generateConnectionId = generateConnectionId;
+exports.generateNodeId = generateNodeId;
+exports.getNodeBounds = getNodeBounds;
+exports.getNodeConnections = getNodeConnections;
+exports.getNodeDefinition = getNodeDefinition;
+exports.getPortConnections = getPortConnections;
+exports.graphToScreen = graphToScreen;
+exports.importGraphFromJSON = importGraphFromJSON;
+exports.moveNodesInGraph = moveNodesInGraph;
+exports.removeConnectionFromGraph = removeConnectionFromGraph;
+exports.removeNodesFromGraph = removeNodesFromGraph;
+exports.resetIdCounters = resetIdCounters;
+exports.screenToGraph = screenToGraph;
+exports.topologicalSort = topologicalSort;
+exports.updateNodeInGraph = updateNodeInGraph;
+exports.validateGraph = validateGraph;
+//# sourceMappingURL=materialEditorUtils.js.map