Add custom nodes, Civitai loras (LFS), and vast.ai setup script

Includes 30 custom nodes committed directly, 7 Civitai-exclusive
loras stored via Git LFS, and a setup script that installs all
dependencies and downloads HuggingFace-hosted models on vast.ai.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

custom_nodes/ComfyUI-KJNodes/utility/magictex.py

@@ -0,0 +1,95 @@
+"""Generates psychedelic color textures in the spirit of Blender's magic texture shader using Python/Numpy
+
+https://github.com/cheind/magic-texture
+"""
+from typing import Tuple, Optional
+import numpy as np
+
+
+def coordinate_grid(shape: Tuple[int, int], dtype=np.float32):
+    """Returns a three-dimensional coordinate grid of given shape for use in `magic`."""
+    x = np.linspace(-1, 1, shape[1], endpoint=True, dtype=dtype)
+    y = np.linspace(-1, 1, shape[0], endpoint=True, dtype=dtype)
+    X, Y = np.meshgrid(x, y)
+    XYZ = np.stack((X, Y, np.ones_like(X)), -1)
+    return XYZ
+
+
+def random_transform(coords: np.ndarray, rng: np.random.Generator = None):
+    """Returns randomly transformed coordinates"""
+    H, W = coords.shape[:2]
+    rng = rng or np.random.default_rng()
+    m = rng.uniform(-1.0, 1.0, size=(3, 3)).astype(coords.dtype)
+    return (coords.reshape(-1, 3) @ m.T).reshape(H, W, 3)
+
+
+def magic(
+    coords: np.ndarray,
+    depth: Optional[int] = None,
+    distortion: Optional[int] = None,
+    rng: np.random.Generator = None,
+):
+    """Returns color magic color texture.
+
+    The implementation is based on Blender's (https://www.blender.org/) magic
+    texture shader. The following adaptions have been made:
+     - we exchange the nested if-cascade by a probabilistic iterative approach
+
+    Kwargs
+    ------
+    coords: HxWx3 array
+        Coordinates transformed into colors by this method. See
+        `magictex.coordinate_grid` to generate the default.
+    depth: int (optional)
+        Number of transformations applied. Higher numbers lead to more
+        nested patterns. If not specified, randomly sampled.
+    distortion: float (optional)
+        Distortion of patterns. Larger values indicate more distortion,
+        lower values tend to generate smoother patterns. If not specified,
+        randomly sampled.
+    rng: np.random.Generator
+        Optional random generator to draw samples from.
+
+    Returns
+    -------
+    colors: HxWx3 array
+        Three channel color image in range [0,1]
+    """
+    rng = rng or np.random.default_rng()
+    if distortion is None:
+        distortion = rng.uniform(1, 4)
+    if depth is None:
+        depth = rng.integers(1, 5)
+
+    H, W = coords.shape[:2]
+    XYZ = coords
+    x = np.sin((XYZ[..., 0] + XYZ[..., 1] + XYZ[..., 2]) * distortion)
+    y = np.cos((-XYZ[..., 0] + XYZ[..., 1] - XYZ[..., 2]) * distortion)
+    z = -np.cos((-XYZ[..., 0] - XYZ[..., 1] + XYZ[..., 2]) * distortion)
+
+    if depth > 0:
+        x *= distortion
+        y *= distortion
+        z *= distortion
+        y = -np.cos(x - y + z)
+        y *= distortion
+
+    xyz = [x, y, z]
+    fns = [np.cos, np.sin]
+    for _ in range(1, depth):
+        axis = rng.choice(3)
+        fn = fns[rng.choice(2)]
+        signs = rng.binomial(n=1, p=0.5, size=4) * 2 - 1
+
+        xyz[axis] = signs[-1] * fn(
+            signs[0] * xyz[0] + signs[1] * xyz[1] + signs[2] * xyz[2]
+        )
+        xyz[axis] *= distortion
+
+    x, y, z = xyz
+    x /= 2 * distortion
+    y /= 2 * distortion
+    z /= 2 * distortion
+    c = 0.5 - np.stack((x, y, z), -1)
+    np.clip(c, 0, 1.0)
+    return c