From cfc636e328c12ced896fcf5f11418bfb0bd6ca13 Mon Sep 17 00:00:00 2001 From: Ilker Manap Date: Wed, 14 Oct 2026 00:51:06 +0200 Subject: [PATCH] A mesh's base colour can be brought to the picture it was made from Stable Fast 3D takes the light out of the picture it sees, and a dark basalt (median 0.17) came back a light stone dimly lit (0.67). The save node takes albedo_match, the picture and its mask, and scales the base colour texture in linear light by the ratio of the object's medians, so marks keep their contrast; texels nothing maps to are left alone. On the game team's rock it is 0.18. A workflow's {{name|false}} default now fills a BOOLEAN input with a boolean rather than the word. Co-Authored-By: Claude Opus 5.5 (1M context) --- CHANGELOG.md | 5 ++ internal/comfy/comfy.go | 4 ++ internal/comfy/comfy_test.go | 16 ++++++ internal/comfy/nodes/llmgw_nodes/__init__.py | 57 ++++++++++++++++++-- 4 files changed, 79 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 938c0a5..f17e286 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,11 @@ APIs change between minors without a deprecation period. ### Added +- **A mesh's base colour brought to its picture's**: `LLMGWSaveMesh` takes + `albedo_match` with the picture and its mask, and scales the texture in + linear light to the object's brightness in the picture. Stable Fast 3D + takes the light out of what it sees and read a dark basalt (0.17) as a + light stone dimly lit (0.67); matched, it is 0.18. - **Picture and 3D models by themselves**: once a node has a card that fits flux-schnell or triposr and the catalog makes nothing of that kind, the leading control plane adds the preset on demand — so a new cluster's diff --git a/internal/comfy/comfy.go b/internal/comfy/comfy.go index 88dad71..826b61e 100644 --- a/internal/comfy/comfy.go +++ b/internal/comfy/comfy.go @@ -222,6 +222,10 @@ func fillString(s string, p Params, missing *[]string) any { if f, err := strconv.ParseFloat(def, 64); err == nil { return f, true } + // A BOOLEAN input refuses the word: {{albedo_match|false}}. + if b, err := strconv.ParseBool(def); err == nil && (def == "true" || def == "false") { + return b, true + } return def, true } *missing = append(*missing, name) diff --git a/internal/comfy/comfy_test.go b/internal/comfy/comfy_test.go index 952c8cf..8ef6184 100644 --- a/internal/comfy/comfy_test.go +++ b/internal/comfy/comfy_test.go @@ -252,3 +252,19 @@ func TestAPictureLosesTheWorkflowComfyUIWroteIntoIt(t *testing.T) { t.Error("a truncated PNG was changed") } } + +func TestATrueOrFalseDefaultIsABoolean(t *testing.T) { + // A BOOLEAN input refuses the word "false": sf3d's albedo_match. + tpl, err := Load((`{"5":{"class_type":"LLMGWSaveMesh","inputs":{"albedo_match":"{{albedo_match|false}}","count":"{{count|2}}","s":"{{s|x}}"}}}`)) + if err != nil { + t.Fatal(err) + } + g, err := tpl.Fill(Params{}) + if err != nil { + t.Fatal(err) + } + in := g["5"].(map[string]any)["inputs"].(map[string]any) + if in["albedo_match"] != false || in["count"] != 2.0 || in["s"] != "x" { + t.Errorf("inputs %#v", in) + } +} diff --git a/internal/comfy/nodes/llmgw_nodes/__init__.py b/internal/comfy/nodes/llmgw_nodes/__init__.py index aeb09d0..e934e51 100644 --- a/internal/comfy/nodes/llmgw_nodes/__init__.py +++ b/internal/comfy/nodes/llmgw_nodes/__init__.py @@ -94,22 +94,60 @@ class LLMGWPrepareForMesh: return (both[..., :3].contiguous(), both[..., 3].contiguous()) +def _to_linear(x): + return np.where(x <= 0.04045, x / 12.92, ((x + 0.055) / 1.055) ** 2.4) + + +def _to_srgb(x): + return np.where(x <= 0.0031308, x * 12.92, 1.055 * np.power(np.clip(x, 0, None), 1 / 2.4) - 0.055) + + +def _match_albedo(tex, reference, mask): + """The texture's brightness brought to the picture's: Stable Fast 3D + takes the light out of what it sees, and a dark object it reads as a + light one dimly lit — a basalt of 0.17 came back 0.67. Scaled in linear + light by the ratio of the medians over the object, so its marks keep + their contrast; texels nothing maps to (black) are left as they are.""" + t = np.asarray(tex.convert("RGB")).astype(np.float64) / 255.0 + used = t.max(-1) > 2 / 255 + ref = reference.cpu().numpy().astype(np.float64) + obj = mask.cpu().numpy() > 0.5 if mask is not None else np.ones(ref.shape[:2], bool) + if used.sum() < 16 or obj.sum() < 16: + return tex + lum = lambda a: a @ np.array([0.2126, 0.7152, 0.0722]) + want = np.median(lum(_to_linear(ref[obj]))) + have = np.median(lum(_to_linear(t[used]))) + if have <= 0: + return tex + k = float(np.clip(want / have, 0.05, 20.0)) + out = t.copy() + out[used] = np.clip(_to_srgb(_to_linear(t[used]) * k), 0, 1) + img = Image.fromarray((out * 255 + 0.5).astype(np.uint8)) + img.format = tex.format + return img + + class LLMGWSaveMesh: """Writes each mesh a 3D node made to output/ as a GLB and names the files, which is how the gate finds a result. A model's own save node may return the mesh as base64 (Stable Fast 3D's does) or as an OBJ - without its texture, and the gate reads neither.""" + without its texture, and the gate reads neither. + + With albedo_match and the picture the mesh was made from (and its + mask), the mesh's base colour is brought to the picture's brightness.""" @classmethod def INPUT_TYPES(cls): - return {"required": {"mesh": ("MESH",), "filename_prefix": ("STRING", {"default": "mesh"})}} + return {"required": {"mesh": ("MESH",), "filename_prefix": ("STRING", {"default": "mesh"})}, + "optional": {"albedo_match": ("BOOLEAN", {"default": False}), + "reference": ("IMAGE",), "reference_mask": ("MASK",)}} RETURN_TYPES = () OUTPUT_NODE = True FUNCTION = "save" CATEGORY = "llmgw" - def save(self, mesh, filename_prefix="mesh"): + def save(self, mesh, filename_prefix="mesh", albedo_match=False, reference=None, reference_mask=None): import os import folder_paths import trimesh @@ -119,6 +157,9 @@ class LLMGWSaveMesh: filename_prefix, folder_paths.get_output_directory()) saved = [] for i, m in enumerate(mesh if isinstance(mesh, (list, tuple)) else [mesh]): + if albedo_match and reference is not None: + _match_scene(m, reference[min(i, reference.shape[0] - 1)], + None if reference_mask is None else reference_mask[min(i, reference_mask.shape[0] - 1)]) file = f"{name.replace('%batch_num%', str(i))}_{counter + i:05}_.glb" scene = m if isinstance(m, trimesh.Scene) else trimesh.Scene(m) with open(os.path.join(folder, file), "wb") as f: @@ -127,6 +168,16 @@ class LLMGWSaveMesh: return {"ui": {"mesh": saved}} +def _match_scene(m, reference, mask): + """_match_albedo on every base colour texture of a mesh or scene.""" + geoms = m.geometry.values() if hasattr(m, "geometry") else [m] + for g in geoms: + mat = getattr(getattr(g, "visual", None), "material", None) + tex = getattr(mat, "baseColorTexture", None) + if tex is not None: + mat.baseColorTexture = _match_albedo(tex, reference, mask) + + NODE_CLASS_MAPPINGS = {"LLMGWPrepareForMesh": LLMGWPrepareForMesh, "LLMGWSaveMesh": LLMGWSaveMesh} NODE_DISPLAY_NAME_MAPPINGS = {"LLMGWPrepareForMesh": "Prepare a picture for a 3D model (llmgw)", "LLMGWSaveMesh": "Save a mesh as GLB (llmgw)"}