@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-TG7O4WBC.js

@@ -0,0 +1,406 @@
+// src/compiler/NodeToyMapping.ts
+var NODE_TYPE_MAP = {
+  // Math operations
+  Add: { expression: "({in:a} + {in:b})", outputType: "float" },
+  Subtract: { expression: "({in:a} - {in:b})", outputType: "float" },
+  Multiply: { expression: "({in:a} * {in:b})", outputType: "float" },
+  Divide: { expression: "({in:a} / max({in:b}, 0.0001))", outputType: "float" },
+  Power: { expression: "pow({in:a}, {in:b})", outputType: "float" },
+  Sqrt: { expression: "sqrt({in:a})", outputType: "float" },
+  Abs: { expression: "abs({in:a})", outputType: "float" },
+  Sign: { expression: "sign({in:a})", outputType: "float" },
+  Floor: { expression: "floor({in:a})", outputType: "float" },
+  Ceil: { expression: "ceil({in:a})", outputType: "float" },
+  Fract: { expression: "fract({in:a})", outputType: "float" },
+  Mod: { expression: "mod({in:a}, {in:b})", outputType: "float" },
+  Min: { expression: "min({in:a}, {in:b})", outputType: "float" },
+  Max: { expression: "max({in:a}, {in:b})", outputType: "float" },
+  Clamp: { expression: "clamp({in:a}, {in:min}, {in:max})", outputType: "float" },
+  Lerp: { expression: "mix({in:a}, {in:b}, {in:t})", outputType: "float" },
+  Smoothstep: { expression: "smoothstep({in:edge0}, {in:edge1}, {in:x})", outputType: "float" },
+  Step: { expression: "step({in:edge}, {in:x})", outputType: "float" },
+  OneMinus: { expression: "(1.0 - {in:a})", outputType: "float" },
+  Negate: { expression: "(-{in:a})", outputType: "float" },
+  Length: { expression: "length({in:a})", outputType: "float" },
+  Distance: { expression: "distance({in:a}, {in:b})", outputType: "float" },
+  Dot: { expression: "dot({in:a}, {in:b})", outputType: "float" },
+  Cross: { expression: "cross({in:a}, {in:b})", outputType: "vec3" },
+  Normalize: { expression: "normalize({in:a})", outputType: "vec3" },
+  Reflect: { expression: "reflect({in:a}, {in:b})", outputType: "vec3" },
+  // Trigonometry
+  Sin: { expression: "sin({in:a})", outputType: "float" },
+  Cos: { expression: "cos({in:a})", outputType: "float" },
+  Tan: { expression: "tan({in:a})", outputType: "float" },
+  Asin: { expression: "asin({in:a})", outputType: "float" },
+  Acos: { expression: "acos({in:a})", outputType: "float" },
+  Atan: { expression: "atan({in:a})", outputType: "float" },
+  Atan2: { expression: "atan({in:y}, {in:x})", outputType: "float" },
+  // Color operations
+  Mix: { expression: "mix({in:a}, {in:b}, {in:factor})", outputType: "vec3" },
+  Saturate: { expression: "clamp({in:a}, 0.0, 1.0)", outputType: "float" },
+  // Constructors
+  Vec2: { expression: "vec2({in:x}, {in:y})", outputType: "vec2" },
+  Vec3: { expression: "vec3({in:x}, {in:y}, {in:z})", outputType: "vec3" },
+  Vec4: { expression: "vec4({in:x}, {in:y}, {in:z}, {in:w})", outputType: "vec4" },
+  // Component extraction
+  SplitVec2: { expression: "{in:a}", outputType: "float" },
+  SplitVec3: { expression: "{in:a}", outputType: "float" },
+  SplitVec4: { expression: "{in:a}", outputType: "float" },
+  // Texture sampling
+  Texture2D: { expression: "texture2D({in:sampler}, {in:uv})", outputType: "vec4" },
+  CubeMap: { expression: "textureCube({in:sampler}, {in:dir})", outputType: "vec4" },
+  // Noise
+  ProceduralNoise: { expression: "snoise({in:uv} * {in:scale})", outputType: "float" }
+};
+var BUILTIN_INPUT_NODES = /* @__PURE__ */ new Set([
+  "Time",
+  "Resolution",
+  "ScreenUV",
+  "UV",
+  "Normal",
+  "Position",
+  "ViewDirection",
+  "FragCoord",
+  "Constant",
+  "Parameter"
+]);
+var OUTPUT_NODES = /* @__PURE__ */ new Set(["FragColor", "Output", "Emission", "Alpha", "Discard"]);
+function mapNodeToyToShader(graph, options = {}) {
+  const mapper = new NodeToyMapper(options);
+  return mapper.map(graph);
+}
+var NodeToyMapper = class {
+  constructor(options = {}) {
+    this.warnings = [];
+    this.unsupportedNodes = [];
+    this.uniforms = {};
+    this.varyingDecls = [];
+    this.fragmentLines = [];
+    this.nodeOutputVars = /* @__PURE__ */ new Map();
+    this.nodeMap = /* @__PURE__ */ new Map();
+    this.edgesByTarget = /* @__PURE__ */ new Map();
+    this.visitedNodes = /* @__PURE__ */ new Set();
+    this.language = options.language ?? "glsl";
+    this.autoTimeUniform = options.autoTimeUniform ?? true;
+    this.autoResolutionUniform = options.autoResolutionUniform ?? true;
+    this.variablePrefix = options.variablePrefix ?? "nt_";
+    this.optimization = options.optimization ?? "basic";
+  }
+  map(graph) {
+    this.warnings = [];
+    this.unsupportedNodes = [];
+    this.uniforms = {};
+    this.varyingDecls = [];
+    this.fragmentLines = [];
+    this.nodeOutputVars.clear();
+    this.nodeMap.clear();
+    this.edgesByTarget.clear();
+    this.visitedNodes.clear();
+    for (const node of graph.nodes) {
+      this.nodeMap.set(node.id, node);
+    }
+    for (const edge of graph.edges) {
+      const key = `${edge.toNode}:${edge.toPort}`;
+      if (!this.edgesByTarget.has(key)) {
+        this.edgesByTarget.set(key, []);
+      }
+      this.edgesByTarget.get(key).push(edge);
+    }
+    const outputNodes = graph.nodes.filter((n) => OUTPUT_NODES.has(n.type));
+    if (outputNodes.length === 0) {
+      this.warnings.push("No output node found in graph; generating passthrough shader");
+    }
+    for (const outputNode of outputNodes) {
+      this.traverseNode(outputNode.id);
+    }
+    const hasTimeNode = graph.nodes.some((n) => n.type === "Time");
+    const hasResolutionNode = graph.nodes.some((n) => n.type === "Resolution");
+    if (this.autoTimeUniform && hasTimeNode) {
+      this.uniforms["time"] = { type: "float", value: 0 };
+    }
+    if (this.autoResolutionUniform && hasResolutionNode) {
+      this.uniforms["resolution"] = { type: "vec2", value: [1920, 1080] };
+    }
+    for (const node of graph.nodes) {
+      if (node.type === "Parameter" || node.type === "Constant") {
+        this.extractParameterUniform(node);
+      }
+    }
+    const vertexSource = this.generateVertexSource();
+    const fragmentSource = this.generateFragmentSource(outputNodes);
+    const shaderConfig = {
+      name: graph.name || "nodetoy_shader",
+      source: {
+        language: this.language,
+        vertex: vertexSource,
+        fragment: fragmentSource
+      },
+      uniforms: this.uniforms,
+      blendMode: graph.settings?.blendMode ?? "opaque",
+      depthTest: graph.settings?.depthTest ?? true,
+      depthWrite: graph.settings?.depthWrite ?? true,
+      cullFace: graph.settings?.doubleSided ? "none" : "back"
+    };
+    return {
+      shaderConfig,
+      vertexSource,
+      fragmentSource,
+      uniforms: this.uniforms,
+      warnings: this.warnings,
+      unsupportedNodes: this.unsupportedNodes
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Graph traversal (reverse topological from output nodes)
+  // ---------------------------------------------------------------------------
+  traverseNode(nodeId) {
+    if (this.nodeOutputVars.has(nodeId)) {
+      return this.nodeOutputVars.get(nodeId);
+    }
+    if (this.visitedNodes.has(nodeId)) {
+      this.warnings.push(`Cycle detected at node ${nodeId}; breaking with default value`);
+      return "0.0";
+    }
+    this.visitedNodes.add(nodeId);
+    const node = this.nodeMap.get(nodeId);
+    if (!node) {
+      this.warnings.push(`Missing node: ${nodeId}`);
+      return "0.0";
+    }
+    if (BUILTIN_INPUT_NODES.has(node.type)) {
+      const varExpr = this.resolveBuiltinNode(node);
+      this.nodeOutputVars.set(nodeId, varExpr);
+      return varExpr;
+    }
+    if (OUTPUT_NODES.has(node.type)) {
+      for (const input of node.inputs) {
+        const inputExpr = this.resolveInputPort(nodeId, input.name, input);
+        if (node.type === "FragColor" || node.type === "Output") {
+          this.fragmentLines.push(`  // Output: ${node.label || node.type}`);
+          if (input.type === "vec4") {
+            this.fragmentLines.push(`  gl_FragColor = ${inputExpr};`);
+          } else if (input.type === "vec3") {
+            this.fragmentLines.push(`  gl_FragColor = vec4(${inputExpr}, 1.0);`);
+          } else {
+            this.fragmentLines.push(`  gl_FragColor = vec4(vec3(${inputExpr}), 1.0);`);
+          }
+        }
+      }
+      const varName2 = `${this.variablePrefix}out_${this.sanitize(nodeId)}`;
+      this.nodeOutputVars.set(nodeId, varName2);
+      return varName2;
+    }
+    const codegen = NODE_TYPE_MAP[node.type];
+    if (!codegen) {
+      this.unsupportedNodes.push(node.type);
+      this.warnings.push(`Unsupported node type: ${node.type}; using default value`);
+      this.nodeOutputVars.set(nodeId, "0.0");
+      return "0.0";
+    }
+    const resolvedInputs = {};
+    for (const input of node.inputs) {
+      resolvedInputs[input.name] = this.resolveInputPort(nodeId, input.name, input);
+    }
+    let expression = codegen.expression;
+    for (const [portName, portExpr] of Object.entries(resolvedInputs)) {
+      expression = expression.replace(`{in:${portName}}`, portExpr);
+    }
+    expression = expression.replace(/\{in:\w+\}/g, "0.0");
+    const varName = `${this.variablePrefix}${this.sanitize(nodeId)}`;
+    const glslType = this.uniformTypeToGLSL(codegen.outputType);
+    this.fragmentLines.push(`  ${glslType} ${varName} = ${expression};`);
+    this.nodeOutputVars.set(nodeId, varName);
+    return varName;
+  }
+  resolveInputPort(nodeId, portName, port) {
+    const edgeKey = `${nodeId}:${portName}`;
+    const edges = this.edgesByTarget.get(edgeKey);
+    if (edges && edges.length > 0) {
+      const edge = edges[0];
+      return this.traverseNode(edge.fromNode);
+    }
+    if (port.default !== void 0) {
+      if (typeof port.default === "number") return String(port.default);
+      if (Array.isArray(port.default)) {
+        const len = port.default.length;
+        if (len === 2) return `vec2(${port.default.join(", ")})`;
+        if (len === 3) return `vec3(${port.default.join(", ")})`;
+        if (len === 4) return `vec4(${port.default.join(", ")})`;
+        return String(port.default[0] ?? 0);
+      }
+    }
+    return "0.0";
+  }
+  resolveBuiltinNode(node) {
+    switch (node.type) {
+      case "Time":
+        return "time";
+      case "Resolution":
+        return "resolution";
+      case "UV":
+      case "ScreenUV":
+        this.ensureVarying("vUv", "vec2");
+        return "vUv";
+      case "Normal":
+        this.ensureVarying("vNormal", "vec3");
+        return "vNormal";
+      case "Position":
+        this.ensureVarying("vPosition", "vec3");
+        return "vPosition";
+      case "ViewDirection":
+        this.ensureVarying("vViewDir", "vec3");
+        return "vViewDir";
+      case "FragCoord":
+        return "gl_FragCoord.xy";
+      case "Constant": {
+        const val = node.params?.["value"];
+        if (typeof val === "number") return String(val);
+        if (Array.isArray(val)) {
+          if (val.length === 2) return `vec2(${val.join(", ")})`;
+          if (val.length === 3) return `vec3(${val.join(", ")})`;
+          if (val.length === 4) return `vec4(${val.join(", ")})`;
+        }
+        return "0.0";
+      }
+      case "Parameter": {
+        const name = node.params?.["name"] || `param_${node.id}`;
+        return name;
+      }
+      default:
+        return "0.0";
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Uniform and varying management
+  // ---------------------------------------------------------------------------
+  extractParameterUniform(node) {
+    const name = node.params?.["name"] || `param_${node.id}`;
+    const value = node.params?.["value"];
+    const uniformType = this.inferUniformType(value);
+    if (!this.uniforms[name]) {
+      this.uniforms[name] = {
+        type: uniformType,
+        value: typeof value === "number" || Array.isArray(value) ? value : 0,
+        min: node.params?.["min"],
+        max: node.params?.["max"],
+        label: node.label
+      };
+    }
+  }
+  inferUniformType(value) {
+    if (typeof value === "number") return "float";
+    if (typeof value === "boolean") return "bool";
+    if (Array.isArray(value)) {
+      if (value.length === 2) return "vec2";
+      if (value.length === 3) return "vec3";
+      if (value.length === 4) return "vec4";
+      if (value.length === 9) return "mat3";
+      if (value.length === 16) return "mat4";
+    }
+    return "float";
+  }
+  ensureVarying(name, type) {
+    const decl = `varying ${type} ${name};`;
+    if (!this.varyingDecls.includes(decl)) {
+      this.varyingDecls.push(decl);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Source generation
+  // ---------------------------------------------------------------------------
+  generateVertexSource() {
+    const lines = [];
+    for (const decl of this.varyingDecls) {
+      lines.push(decl);
+    }
+    lines.push("");
+    lines.push("void main() {");
+    if (this.varyingDecls.some((d) => d.includes("vUv"))) {
+      lines.push("  vUv = uv;");
+    }
+    if (this.varyingDecls.some((d) => d.includes("vNormal"))) {
+      lines.push("  vNormal = normalize(normalMatrix * normal);");
+    }
+    if (this.varyingDecls.some((d) => d.includes("vPosition"))) {
+      lines.push("  vPosition = position;");
+    }
+    if (this.varyingDecls.some((d) => d.includes("vViewDir"))) {
+      lines.push("  vec4 mvPos = modelViewMatrix * vec4(position, 1.0);");
+      lines.push("  vViewDir = normalize(-mvPos.xyz);");
+    }
+    lines.push("  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);");
+    lines.push("}");
+    return lines.join("\n");
+  }
+  generateFragmentSource(outputNodes) {
+    const lines = [];
+    lines.push("precision highp float;");
+    lines.push("");
+    for (const [name, uniform] of Object.entries(this.uniforms)) {
+      lines.push(`uniform ${this.uniformTypeToGLSL(uniform.type)} ${name};`);
+    }
+    lines.push("");
+    for (const decl of this.varyingDecls) {
+      lines.push(decl);
+    }
+    lines.push("");
+    if (this.nodeMap.size > 0) {
+      const hasNoise = Array.from(this.nodeMap.values()).some((n) => n.type === "ProceduralNoise");
+      if (hasNoise) {
+        lines.push(SIMPLEX_NOISE_2D);
+        lines.push("");
+      }
+    }
+    lines.push("void main() {");
+    for (const line of this.fragmentLines) {
+      lines.push(line);
+    }
+    if (!this.fragmentLines.some((l) => l.includes("gl_FragColor"))) {
+      lines.push("  gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0); // No output node");
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  uniformTypeToGLSL(type) {
+    return type;
+  }
+  sanitize(id) {
+    return id.replace(/[^a-zA-Z0-9]/g, "_");
+  }
+};
+var SIMPLEX_NOISE_2D = `
+// Simplex 2D noise for ProceduralNoise nodes
+vec3 mod289_n(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec2 mod289_n(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec3 permute_n(vec3 x) { return mod289_n(((x*34.0)+1.0)*x); }
+
+float snoise(vec2 v) {
+  const vec4 C = vec4(0.211324865405187, 0.366025403784439,
+                      -0.577350269189626, 0.024390243902439);
+  vec2 i = floor(v + dot(v, C.yy));
+  vec2 x0 = v - i + dot(i, C.xx);
+  vec2 i1 = (x0[0] > x0[1]) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+  i = mod289_n(i);
+  vec3 p = permute_n(permute_n(i[1] + vec3(0.0, i1[1], 1.0)) + i[0] + vec3(0.0, i1[0], 1.0));
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m; m = m*m;
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+  m *= 1.79284291400159 - 0.85373472095314 * (a0*a0 + h*h);
+  vec3 g;
+  g[0] = a0[0] * x0[0] + h[0] * x0[1];
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}`.trim();
+var NodeToyMapping_default = mapNodeToyToShader;
+
+export { NodeToyMapper, NodeToyMapping_default, mapNodeToyToShader };
+//# sourceMappingURL=chunk-TG7O4WBC.js.map
+//# sourceMappingURL=chunk-TG7O4WBC.js.map