@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-D6BUOHUG.js

@@ -0,0 +1,634 @@
+import {
+  randomRegistration,
+  remapRegistration
+} from "./chunk-RXDIMXN5.js";
+import {
+  lookAtRotation
+} from "./chunk-DEQSEFFH.js";
+
+// packages/runtime/src/builtins/core/bundle.ts
+var pickDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Pick",
+  description: "Reads one field of a bundle",
+  icon: "ListFilter",
+  inputs: {
+    bundle: { kind: "data", type: "bundle" }
+  },
+  outputs: {
+    value: { kind: "data", type: "any" }
+  },
+  props: {
+    field: { type: "string", default: "", label: "Field" }
+  }
+};
+var packDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Pack",
+  description: "Collects inputs into a bundle, one named field each",
+  icon: "Package",
+  inputs: {
+    inputs: { kind: "data", type: "any", variadic: true }
+  },
+  outputs: {
+    bundle: { kind: "data", type: "bundle" }
+  },
+  props: {
+    names: {
+      type: "string",
+      default: "",
+      label: "Field names",
+      description: "Comma-separated, one per input in order; an unnamed input becomes field_<n>"
+    }
+  }
+};
+function packFieldNames(names, count) {
+  const declared = String(names ?? "").split(",").map((name) => name.trim());
+  return Array.from({ length: count }, (_, index) => declared[index] || `field_${index}`);
+}
+var pickRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Pick",
+  definition: pickDefinition,
+  loadExecute: async () => ({ inputs, outputs, props }) => {
+    const bundle = inputs.bundle;
+    const field = props.field.trim();
+    outputs.value.set(
+      bundle && field && Object.prototype.hasOwnProperty.call(bundle, field) ? bundle[field] : null
+    );
+  }
+};
+var packRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Pack",
+  definition: packDefinition,
+  loadExecute: async () => ({ inputs, outputs, props }) => {
+    const values = inputs.inputs;
+    const names = packFieldNames(props.names, values.length);
+    const bundle = {};
+    names.forEach((name, index) => {
+      if (values[index] !== void 0) bundle[name] = values[index];
+    });
+    outputs.bundle.set(bundle);
+  }
+};
+
+// packages/contracts/src/camera.ts
+var CAMERA_DEFAULTS = Object.freeze({
+  translate: [0, 0, 0],
+  rotate: [0, 0, 0],
+  focal: 50,
+  aperture: 41.4214,
+  near: 1e-3,
+  far: 1e4,
+  resolution: [1280, 720],
+  aspect: 1,
+  projection: "perspective",
+  orthowidth: 2
+});
+function isCamera(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return Array.isArray(candidate.translate) && Array.isArray(candidate.rotate) && typeof candidate.focal === "number" && typeof candidate.aperture === "number";
+}
+
+// packages/runtime/src/builtins/core/camera.ts
+var cameraDefinition = {
+  apiVersion: 1,
+  label: "Camera",
+  description: "A camera, following Houdini's /obj/cam.",
+  icon: "Video",
+  runsOn: "portable",
+  inputs: {
+    translate: {
+      kind: "data",
+      type: "vec3",
+      default: [0, 0, 5],
+      description: "World position."
+    },
+    rotate: {
+      kind: "data",
+      type: "vec3",
+      default: [0, 0, 0],
+      description: "Degrees, XYZ order. The camera looks down its own -Z."
+    },
+    focal: {
+      kind: "data",
+      type: "float",
+      default: 50,
+      min: 1,
+      max: 300,
+      description: "Focal length in millimetres."
+    },
+    lookat: {
+      kind: "data",
+      type: "vec3",
+      default: [0, 0, 0],
+      description: "Point to aim at. Used only when Look At is on, and it replaces Rotate."
+    },
+    up: {
+      kind: "data",
+      type: "vec3",
+      default: [0, 1, 0],
+      description: "Up vector for Look At."
+    },
+    spin: {
+      kind: "data",
+      type: "float",
+      default: 0,
+      description: "Degrees added to the Y rotation, after Look At. For turntables."
+    }
+  },
+  outputs: {
+    camera: { kind: "data", type: "camera" }
+  },
+  props: {
+    lookAt: {
+      type: "bool",
+      default: false,
+      label: "Look At",
+      description: "Aim at the Look At point instead of using Rotate."
+    },
+    aperture: {
+      type: "float",
+      default: 41.4214,
+      min: 1,
+      max: 200,
+      label: "Aperture",
+      description: "Horizontal aperture in millimetres. With the default focal length this is a 45 degree view."
+    },
+    resolution: {
+      type: "vec2i",
+      default: [1280, 720],
+      label: "Resolution",
+      description: "Frame size in pixels. The vertical field of view is derived from this."
+    },
+    aspect: {
+      type: "float",
+      default: 1,
+      min: 0.1,
+      max: 10,
+      label: "Pixel Aspect",
+      description: "The aspect of one pixel, not of the frame."
+    },
+    projection: {
+      type: "string",
+      default: "perspective",
+      label: "Projection",
+      control: "select",
+      options: [
+        { value: "perspective", label: "Perspective" },
+        { value: "orthographic", label: "Orthographic" }
+      ]
+    },
+    orthowidth: {
+      type: "float",
+      default: 2,
+      min: 0.01,
+      label: "Ortho Width",
+      description: "Width of the orthographic frame in world units."
+    },
+    near: { type: "float", default: 1e-3, min: 0, label: "Near Clip" },
+    far: { type: "float", default: 1e4, min: 0, label: "Far Clip" }
+  }
+};
+function executeCamera(context) {
+  const { translate, rotate, focal, lookat, up, spin } = context.inputs;
+  const props = context.props;
+  const aimed = props.lookAt ? lookAtRotation(translate, lookat, up) : rotate;
+  const oriented = spin === 0 ? aimed : [aimed[0], aimed[1] + spin, aimed[2]];
+  const camera = {
+    ...CAMERA_DEFAULTS,
+    translate,
+    rotate: oriented,
+    focal,
+    aperture: props.aperture,
+    resolution: props.resolution,
+    aspect: props.aspect,
+    projection: props.projection === "orthographic" ? "orthographic" : "perspective",
+    orthowidth: props.orthowidth,
+    near: props.near,
+    far: props.far
+  };
+  context.outputs.camera.set(camera);
+}
+var cameraRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Camera",
+  definition: cameraDefinition,
+  loadExecute: async () => executeCamera
+};
+
+// packages/runtime/src/builtins/core/routing.ts
+var switchDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Switch",
+  description: "Selects one input by index",
+  icon: "GitBranch",
+  inputs: {
+    inputs: { kind: "data", type: "any", variadic: true }
+  },
+  outputs: {
+    output: { kind: "data", type: "any" }
+  },
+  props: {
+    index: { type: "int", default: 0, min: 0, step: 1 }
+  }
+};
+var mergeDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Merge",
+  description: "Collects inputs into an array",
+  icon: "GitMerge",
+  inputs: {
+    inputs: { kind: "data", type: "any", variadic: true }
+  },
+  outputs: {
+    output: { kind: "data", type: "array" }
+  },
+  props: {
+    append: { type: "bool", default: false }
+  }
+};
+var selectDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Select",
+  description: "Selects an array item by index",
+  icon: "ListFilter",
+  inputs: {
+    array: { kind: "data", type: "array", default: [] }
+  },
+  outputs: {
+    item: { kind: "data", type: "any" },
+    count: { kind: "data", type: "int" }
+  },
+  props: {
+    index: { type: "int", default: 0, min: 0, step: 1 },
+    wrap: { type: "bool", default: true }
+  }
+};
+var nullDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Null",
+  description: "Passes its input through unchanged",
+  icon: "Circle",
+  inputs: {
+    input: { kind: "data", type: "any", default: null }
+  },
+  outputs: {
+    output: { kind: "data", type: "any" }
+  }
+};
+var frozenDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Frozen",
+  description: "Emits a frozen snapshot of a data source's chosen values",
+  icon: "Snowflake",
+  outputs: {
+    value: { kind: "data", type: "any" }
+  },
+  props: {
+    value: { type: "any", default: null }
+  }
+};
+var frozenRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Frozen",
+  definition: frozenDefinition,
+  loadExecute: async () => ({ outputs, props }) => {
+    outputs.value.set(props.value);
+  }
+};
+var switchRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Switch",
+  definition: switchDefinition,
+  loadExecute: async () => ({ inputs, outputs, props }) => {
+    const values = inputs.inputs;
+    if (!values.length) {
+      outputs.output.set(null);
+      return;
+    }
+    const index = Math.max(0, Math.min(props.index, values.length - 1));
+    outputs.output.set(values[index]);
+  }
+};
+var mergeRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Merge",
+  definition: mergeDefinition,
+  loadExecute: async () => ({ inputs, outputs, props }) => {
+    const values = inputs.inputs.filter((value) => value !== null);
+    outputs.output.set(
+      props.append && Array.isArray(values[0]) ? [...values[0], ...values.slice(1)] : values
+    );
+  }
+};
+var selectRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Select",
+  definition: selectDefinition,
+  loadExecute: async () => ({ inputs, outputs, props }) => {
+    const count = inputs.array.length;
+    outputs.count.set(count);
+    if (!count) {
+      outputs.item.set(null);
+      return;
+    }
+    const index = props.wrap ? (props.index % count + count) % count : Math.max(0, Math.min(props.index, count - 1));
+    outputs.item.set(inputs.array[index]);
+  }
+};
+var nullRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Null",
+  definition: nullDefinition,
+  loadExecute: async () => ({ inputs, outputs }) => {
+    outputs.output.set(inputs.input);
+  }
+};
+
+// packages/runtime/src/builtins/core/structural.ts
+var inputDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Input",
+  description: "Defines a public graph or subnet input",
+  icon: "LogIn",
+  inputs: {
+    value: { kind: "data", type: "any", default: null }
+  },
+  outputs: {
+    output: { kind: "data", type: "any" }
+  },
+  props: {
+    inputIndex: { type: "int", default: 0, min: 0, step: 1 },
+    inputName: { type: "string", default: "" },
+    dataType: { type: "string", default: "any" }
+  }
+};
+var outputDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Output",
+  description: "Defines a public graph or subnet output",
+  icon: "LogOut",
+  inputs: {
+    input: { kind: "data", type: "any", default: null }
+  },
+  outputs: {
+    output: { kind: "data", type: "any" }
+  },
+  props: {
+    outputIndex: { type: "int", default: 0, min: 0, step: 1 },
+    outputName: { type: "string", default: "" },
+    dataType: { type: "string", default: "any" }
+  }
+};
+var subnetDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  container: "subnet",
+  label: "Subnet",
+  description: "Contains a nested deterministic graph",
+  icon: "Folder"
+};
+var feedbackDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  container: "feedback",
+  label: "Feedback",
+  description: "Runs its contents once per step, carrying the previous result forward.",
+  icon: "Repeat",
+  inputs: {
+    initial: {
+      kind: "data",
+      type: "any",
+      default: null,
+      description: "The state the first step starts from."
+    },
+    steps: {
+      kind: "data",
+      type: "int",
+      default: 1,
+      min: 0,
+      description: "How many times the contents run. Drive it from a Time node."
+    }
+  },
+  outputs: {
+    result: {
+      kind: "data",
+      type: "any",
+      description: "The last step's result, or `initial` when steps is zero."
+    },
+    /**
+     * Every kept step, oldest first.
+     *
+     * This exists because **a trail needs the history, not the final state**,
+     * and nothing outside the loop could reconstruct it: a downstream node sees
+     * one frame, which draws nothing. Houdini's Trail SOP has the same
+     * requirement and solves it the same way, by being given the frames.
+     *
+     * Empty unless `history` is non-zero, because the alternative is a
+     * simulation that quietly holds 120 copies of its own geometry — and at
+     * a few thousand particles that is the difference between a preview and a
+     * tab that runs out of memory.
+     */
+    history: {
+      kind: "data",
+      type: "array",
+      description: "The kept step results, oldest first. Empty unless History is set."
+    }
+  },
+  props: {
+    /**
+     * How many step results to keep, newest-biased: `0` keeps none, `N` keeps
+     * the last `N`.
+     *
+     * A prop rather than an input because it is structural — how much memory
+     * this loop is allowed — rather than something to animate. It is also a
+     * cap rather than a flag on purpose: "keep everything" is not offered,
+     * because the honest version of that is a number somebody chose.
+     */
+    history: {
+      type: "int",
+      default: 0,
+      min: 0,
+      max: 1e5,
+      label: "History",
+      description: "Keep the last N step results on the history output. 0 keeps none."
+    }
+  }
+};
+var previousDefinition = {
+  apiVersion: 1,
+  runsOn: "portable",
+  label: "Previous",
+  description: "The previous step's state, inside a Feedback container. The first step gets the container's initial value.",
+  icon: "Rewind",
+  inputs: {
+    initial: {
+      kind: "data",
+      type: "any",
+      default: null,
+      description: "Used only outside a Feedback container."
+    }
+  },
+  outputs: {
+    value: { kind: "data", type: "any", description: "The carried state." },
+    step: { kind: "data", type: "int", description: "Zero-based step index." }
+  },
+  props: {}
+};
+var inputRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Input",
+  definition: inputDefinition,
+  loadExecute: async () => ({ inputs, outputs }) => outputs.output.set(inputs.value)
+};
+var outputRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Output",
+  definition: outputDefinition,
+  loadExecute: async () => ({ inputs, outputs }) => outputs.output.set(inputs.input)
+};
+var subnetRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Subnet",
+  definition: subnetDefinition,
+  loadExecute: async () => () => {
+  }
+};
+var feedbackRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Feedback",
+  definition: feedbackDefinition,
+  loadExecute: async () => () => {
+  }
+};
+var previousRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Previous",
+  definition: previousDefinition,
+  loadExecute: async () => ({ inputs, outputs }) => {
+    outputs.value.set(inputs.initial);
+    outputs.step.set(0);
+  }
+};
+
+// packages/runtime/src/builtins/core/time.ts
+var timeDefinition = {
+  apiVersion: 1,
+  label: "Time",
+  description: "The current frame and time, as values the graph can read.",
+  icon: "Clock",
+  runsOn: "portable",
+  inputs: {},
+  outputs: {
+    /**
+     * The whole frame, as an integer — Houdini's `$F`.
+     *
+     * An `int` rather than a `float`, and that is the point of having two
+     * outputs. Anything that **counts** frames needs an integer: a feedback
+     * container's step count, a sequence index, a modulo. Narrowing is never
+     * implicit in Cascade, so a float frame simply could not be wired to a step
+     * count, and the alternative — truncating silently somewhere downstream —
+     * is a simulation running 3 steps when the graph said 3.7.
+     */
+    frame: {
+      kind: "data",
+      type: "int",
+      description: "The whole frame. Houdini's $F."
+    },
+    /** The fractional frame — Houdini's `$FF`. For anything that moves. */
+    fframe: {
+      kind: "data",
+      type: "float",
+      description: "The fractional frame, for sub-frame motion. Houdini's $FF."
+    },
+    time: {
+      kind: "data",
+      type: "float",
+      description: "The playhead in seconds."
+    }
+  },
+  props: {
+    frame: {
+      type: "int",
+      default: 1,
+      expression: "$F",
+      label: "Frame",
+      description: "Bound to $F. Replace with a number to pin a still, or with any expression."
+    },
+    fframe: {
+      type: "float",
+      default: 1,
+      expression: "$FF",
+      label: "Fractional Frame",
+      description: "Bound to $FF."
+    },
+    time: {
+      type: "float",
+      default: 0,
+      expression: "$T",
+      label: "Time",
+      description: "Bound to $T, in seconds."
+    }
+  }
+};
+function executeTime(context) {
+  context.outputs.frame.set(context.props.frame);
+  context.outputs.fframe.set(context.props.fframe);
+  context.outputs.time.set(context.props.time);
+}
+var timeRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.core.Time",
+  definition: timeDefinition,
+  loadExecute: async () => executeTime
+};
+
+// packages/runtime/src/builtins/core/index.ts
+var coreNodeRegistrations = Object.freeze([
+  subnetRegistration,
+  inputRegistration,
+  outputRegistration,
+  switchRegistration,
+  mergeRegistration,
+  nullRegistration,
+  selectRegistration,
+  pickRegistration,
+  packRegistration,
+  randomRegistration,
+  remapRegistration,
+  cameraRegistration,
+  timeRegistration,
+  feedbackRegistration,
+  previousRegistration,
+  frozenRegistration
+]);
+var registrationsById = new Map(
+  coreNodeRegistrations.map((registration) => [registration.moduleId, registration])
+);
+
+export {
+  isCamera,
+  pickRegistration,
+  packRegistration,
+  cameraRegistration,
+  frozenRegistration,
+  feedbackRegistration,
+  previousRegistration,
+  timeRegistration,
+  coreNodeRegistrations
+};
+//# sourceMappingURL=chunk-D6BUOHUG.js.map