Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

feat: Extend Save3D to save vertex colors and textures (CORE-189) (#13824)

Jukka Seppänen8505abf52e42
diff --git a/comfy_api/latest/_util/geometry_types.py b/comfy_api/latest/_util/geometry_types.py
index b586fceb3..cdde60b10 100644
--- a/comfy_api/latest/_util/geometry_types.py
+++ b/comfy_api/latest/_util/geometry_types.py
@@ -12,9 +12,24 @@ class VOXEL:
class MESH:
- def __init__(self, vertices: torch.Tensor, faces: torch.Tensor):
- self.vertices = vertices
- self.faces = faces
+ def __init__(self, vertices: torch.Tensor, faces: torch.Tensor,
+ uvs: torch.Tensor | None = None,
+ vertex_colors: torch.Tensor | None = None,
+ texture: torch.Tensor | None = None,
+ vertex_counts: torch.Tensor | None = None,
+ face_counts: torch.Tensor | None = None):
+
+ assert (vertex_counts is None) == (face_counts is None), \
+ "vertex_counts and face_counts must be provided together (both or neither)"
+ self.vertices = vertices # vertices: (B, N, 3)
+ self.faces = faces # faces: (B, M, 3)
+ self.uvs = uvs # uvs: (B, N, 2)
+ self.vertex_colors = vertex_colors # vertex_colors: (B, N, 3 or 4)
+ self.texture = texture # texture: (B, H, W, 3)
+ # When vertices/faces are zero-padded to a common N/M across the batch (variable-size mesh batch),
+ # these hold the real per-item lengths (B,). None means rows are uniform and no slicing is needed.
+ self.vertex_counts = vertex_counts
+ self.face_counts = face_counts
class File3D:
diff --git a/comfy_extras/nodes_hunyuan3d.py b/comfy_extras/nodes_hunyuan3d.py
index bf18ecb88..403eb855b 100644
--- a/comfy_extras/nodes_hunyuan3d.py
+++ b/comfy_extras/nodes_hunyuan3d.py
@@ -1,12 +1,7 @@
import torch
-import os
-import json
-import struct
-import numpy as np
from comfy.ldm.modules.diffusionmodules.mmdit import get_1d_sincos_pos_embed_from_grid_torch
-import folder_paths
import comfy.model_management
-from comfy.cli_args import args
+from comfy_extras.nodes_save_3d import pack_variable_mesh_batch
from typing_extensions import override
from comfy_api.latest import ComfyExtension, IO, Types
from comfy_api.latest._util import MESH, VOXEL # only for backward compatibility if someone import it from this file (will be removed later) # noqa
@@ -444,7 +439,9 @@ class VoxelToMeshBasic(IO.ComfyNode):
vertices.append(v)
faces.append(f)
- return IO.NodeOutput(Types.MESH(torch.stack(vertices), torch.stack(faces)))
+ if vertices and all(v.shape == vertices[0].shape for v in vertices) and all(f.shape == faces[0].shape for f in faces):
+ return IO.NodeOutput(Types.MESH(torch.stack(vertices), torch.stack(faces)))
+ return IO.NodeOutput(pack_variable_mesh_batch(vertices, faces))
decode = execute # TODO: remove
@@ -481,206 +478,13 @@ class VoxelToMesh(IO.ComfyNode):
vertices.append(v)
faces.append(f)
- return IO.NodeOutput(Types.MESH(torch.stack(vertices), torch.stack(faces)))
+ if vertices and all(v.shape == vertices[0].shape for v in vertices) and all(f.shape == faces[0].shape for f in faces):
+ return IO.NodeOutput(Types.MESH(torch.stack(vertices), torch.stack(faces)))
+ return IO.NodeOutput(pack_variable_mesh_batch(vertices, faces))
decode = execute # TODO: remove
-def save_glb(vertices, faces, filepath, metadata=None):
- """
- Save PyTorch tensor vertices and faces as a GLB file without external dependencies.
-
- Parameters:
- vertices: torch.Tensor of shape (N, 3) - The vertex coordinates
- faces: torch.Tensor of shape (M, 3) - The face indices (triangle faces)
- filepath: str - Output filepath (should end with .glb)
- """
-
- # Convert tensors to numpy arrays
- vertices_np = vertices.cpu().numpy().astype(np.float32)
- faces_np = faces.cpu().numpy().astype(np.uint32)
-
- vertices_buffer = vertices_np.tobytes()
- indices_buffer = faces_np.tobytes()
-
- def pad_to_4_bytes(buffer):
- padding_length = (4 - (len(buffer) % 4)) % 4
- return buffer + b'\x00' * padding_length
-
- vertices_buffer_padded = pad_to_4_bytes(vertices_buffer)
- indices_buffer_padded = pad_to_4_bytes(indices_buffer)
-
- buffer_data = vertices_buffer_padded + indices_buffer_padded
-
- vertices_byte_length = len(vertices_buffer)
- vertices_byte_offset = 0
- indices_byte_length = len(indices_buffer)
- indices_byte_offset = len(vertices_buffer_padded)
-
- gltf = {
- "asset": {"version": "2.0", "generator": "ComfyUI"},
- "buffers": [
- {
- "byteLength": len(buffer_data)
- }
- ],
- "bufferViews": [
- {
- "buffer": 0,
- "byteOffset": vertices_byte_offset,
- "byteLength": vertices_byte_length,
- "target": 34962 # ARRAY_BUFFER
- },
- {
- "buffer": 0,
- "byteOffset": indices_byte_offset,
- "byteLength": indices_byte_length,
- "target": 34963 # ELEMENT_ARRAY_BUFFER
- }
- ],
- "accessors": [
- {
- "bufferView": 0,
- "byteOffset": 0,
- "componentType": 5126, # FLOAT
- "count": len(vertices_np),
- "type": "VEC3",
- "max": vertices_np.max(axis=0).tolist(),
- "min": vertices_np.min(axis=0).tolist()
- },
- {
- "bufferView": 1,
- "byteOffset": 0,
- "componentType": 5125, # UNSIGNED_INT
- "count": faces_np.size,
- "type": "SCALAR"
- }
- ],
- "meshes": [
- {
- "primitives": [
- {
- "attributes": {
- "POSITION": 0
- },
- "indices": 1,
- "mode": 4 # TRIANGLES
- }
- ]
- }
- ],
- "nodes": [
- {
- "mesh": 0
- }
- ],
- "scenes": [
- {
- "nodes": [0]
- }
- ],
- "scene": 0
- }
-
- if metadata is not None:
- gltf["asset"]["extras"] = metadata
-
- # Convert the JSON to bytes
- gltf_json = json.dumps(gltf).encode('utf8')
-
- def pad_json_to_4_bytes(buffer):
- padding_length = (4 - (len(buffer) % 4)) % 4
- return buffer + b' ' * padding_length
-
- gltf_json_padded = pad_json_to_4_bytes(gltf_json)
-
- # Create the GLB header
- # Magic glTF
- glb_header = struct.pack('<4sII', b'glTF', 2, 12 + 8 + len(gltf_json_padded) + 8 + len(buffer_data))
-
- # Create JSON chunk header (chunk type 0)
- json_chunk_header = struct.pack('<II', len(gltf_json_padded), 0x4E4F534A) # "JSON" in little endian
-
- # Create BIN chunk header (chunk type 1)
- bin_chunk_header = struct.pack('<II', len(buffer_data), 0x004E4942) # "BIN\0" in little endian
-
- # Write the GLB file
- with open(filepath, 'wb') as f:
- f.write(glb_header)
- f.write(json_chunk_header)
- f.write(gltf_json_padded)
- f.write(bin_chunk_header)
- f.write(buffer_data)
-
- return filepath
-
-
-class SaveGLB(IO.ComfyNode):
- @classmethod
- def define_schema(cls):
- return IO.Schema(
- node_id="SaveGLB",
- display_name="Save 3D Model",
- search_aliases=["export 3d model", "save mesh"],
- category="3d",
- essentials_category="Basics",
- is_output_node=True,
- inputs=[
- IO.MultiType.Input(
- IO.Mesh.Input("mesh"),
- types=[
- IO.File3DGLB,
- IO.File3DGLTF,
- IO.File3DOBJ,
- IO.File3DFBX,
- IO.File3DSTL,
- IO.File3DUSDZ,
- IO.File3DAny,
- ],
- tooltip="Mesh or 3D file to save",
- ),
- IO.String.Input("filename_prefix", default="3d/ComfyUI"),
- ],
- hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo]
- )
-
- @classmethod
- def execute(cls, mesh: Types.MESH | Types.File3D, filename_prefix: str) -> IO.NodeOutput:
- full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, folder_paths.get_output_directory())
- results = []
-
- metadata = {}
- if not args.disable_metadata:
- if cls.hidden.prompt is not None:
- metadata["prompt"] = json.dumps(cls.hidden.prompt)
- if cls.hidden.extra_pnginfo is not None:
- for x in cls.hidden.extra_pnginfo:
- metadata[x] = json.dumps(cls.hidden.extra_pnginfo[x])
-
- if isinstance(mesh, Types.File3D):
- # Handle File3D input - save BytesIO data to output folder
- ext = mesh.format or "glb"
- f = f"{filename}_{counter:05}_.{ext}"
- mesh.save_to(os.path.join(full_output_folder, f))
- results.append({
- "filename": f,
- "subfolder": subfolder,
- "type": "output"
- })
- else:
- # Handle Mesh input - save vertices and faces as GLB
- for i in range(mesh.vertices.shape[0]):
- f = f"{filename}_{counter:05}_.glb"
- save_glb(mesh.vertices[i], mesh.faces[i], os.path.join(full_output_folder, f), metadata)
- results.append({
- "filename": f,
- "subfolder": subfolder,
- "type": "output"
- })
- counter += 1
- return IO.NodeOutput(ui={"3d": results})
-
-
class Hunyuan3dExtension(ComfyExtension):
@override
async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -691,7 +495,6 @@ class Hunyuan3dExtension(ComfyExtension):
VAEDecodeHunyuan3D,
VoxelToMeshBasic,
VoxelToMesh,
- SaveGLB,
]
diff --git a/comfy_extras/nodes_save_3d.py b/comfy_extras/nodes_save_3d.py
new file mode 100644
index 000000000..c03524246
--- /dev/null
+++ b/comfy_extras/nodes_save_3d.py
@@ -0,0 +1,396 @@
+"""Save-side 3D nodes: mesh packing/slicing helpers + GLB writer + SaveGLB node."""
+
+import json
+import logging
+import os
+import struct
+from io import BytesIO
+
+import numpy as np
+from PIL import Image
+import torch
+from typing_extensions import override
+
+import folder_paths
+from comfy.cli_args import args
+from comfy_api.latest import ComfyExtension, IO, Types
+
+
+def pack_variable_mesh_batch(vertices, faces, colors=None, uvs=None, texture=None):
+ # Pack lists of (Nᵢ, *) vertex/face/color/uv tensors into padded batched tensors,
+ # stashing per-item lengths as runtime attrs so consumers can recover the real slice.
+ # colors and uvs are 1:1 with vertices, so they're padded to max_vertices and read with vertex_counts.
+ # texture is (B, H, W, 3) — passed through unchanged
+ batch_size = len(vertices)
+ max_vertices = max(v.shape[0] for v in vertices)
+ max_faces = max(f.shape[0] for f in faces)
+
+ packed_vertices = vertices[0].new_zeros((batch_size, max_vertices, vertices[0].shape[1]))
+ packed_faces = faces[0].new_zeros((batch_size, max_faces, faces[0].shape[1]))
+ vertex_counts = torch.tensor([v.shape[0] for v in vertices], device=vertices[0].device, dtype=torch.int64)
+ face_counts = torch.tensor([f.shape[0] for f in faces], device=faces[0].device, dtype=torch.int64)
+
+ for i, (v, f) in enumerate(zip(vertices, faces)):
+ packed_vertices[i, :v.shape[0]] = v
+ packed_faces[i, :f.shape[0]] = f
+
+ packed_colors = None
+ if colors is not None:
+ packed_colors = colors[0].new_zeros((batch_size, max_vertices, colors[0].shape[1]))
+ for i, c in enumerate(colors):
+ assert c.shape[0] == vertices[i].shape[0], (
+ f"vertex_colors[{i}] has {c.shape[0]} entries, expected {vertices[i].shape[0]} (1:1 with vertices)"
+ )
+ packed_colors[i, :c.shape[0]] = c
+
+ packed_uvs = None
+ if uvs is not None:
+ packed_uvs = uvs[0].new_zeros((batch_size, max_vertices, uvs[0].shape[1]))
+ for i, u in enumerate(uvs):
+ assert u.shape[0] == vertices[i].shape[0], (
+ f"uvs[{i}] has {u.shape[0]} entries, expected {vertices[i].shape[0]} (1:1 with vertices)"
+ )
+ packed_uvs[i, :u.shape[0]] = u
+
+ return Types.MESH(packed_vertices, packed_faces,
+ uvs=packed_uvs, vertex_colors=packed_colors, texture=texture,
+ vertex_counts=vertex_counts, face_counts=face_counts)
+
+
+def get_mesh_batch_item(mesh, index):
+ # Returns (vertices, faces, colors, uvs) for batch index, slicing to real lengths
+ # if the mesh carries per-item counts (variable-size batch).
+ v_colors = getattr(mesh, "vertex_colors", None)
+ v_uvs = getattr(mesh, "uvs", None)
+ if getattr(mesh, "vertex_counts", None) is not None:
+ vertex_count = int(mesh.vertex_counts[index].item())
+ face_count = int(mesh.face_counts[index].item())
+ vertices = mesh.vertices[index, :vertex_count]
+ faces = mesh.faces[index, :face_count]
+ colors = v_colors[index, :vertex_count] if v_colors is not None else None
+ uvs = v_uvs[index, :vertex_count] if v_uvs is not None else None
+ return vertices, faces, colors, uvs
+
+ colors = v_colors[index] if v_colors is not None else None
+ uvs = v_uvs[index] if v_uvs is not None else None
+ return mesh.vertices[index], mesh.faces[index], colors, uvs
+
+
+def save_glb(vertices, faces, filepath, metadata=None,
+ uvs=None, vertex_colors=None, texture_image=None):
+ """
+ Save PyTorch tensor vertices and faces as a GLB file without external dependencies.
+
+ Parameters:
+ vertices: torch.Tensor of shape (N, 3) - The vertex coordinates
+ faces: torch.Tensor of shape (M, 3) - The face indices (triangle faces)
+ filepath: str - Output filepath (should end with .glb)
+ metadata: dict - Optional asset.extras metadata
+ uvs: torch.Tensor of shape (N, 2) - Optional per-vertex texture coordinates
+ vertex_colors: torch.Tensor of shape (N, 3) or (N, 4) - Optional per-vertex colors in [0, 1]
+ texture_image: PIL.Image - Optional baseColor texture, embedded as PNG
+ """
+
+ # Convert tensors to numpy arrays
+ vertices_np = vertices.cpu().numpy().astype(np.float32)
+ faces_signed = faces.cpu().numpy().astype(np.int64)
+ uvs_np = uvs.cpu().numpy().astype(np.float32) if uvs is not None else None
+ colors_np = vertex_colors.cpu().numpy().astype(np.float32) if vertex_colors is not None else None
+ if colors_np is not None:
+ colors_np = np.clip(colors_np, 0.0, 1.0)
+
+ n_verts = vertices_np.shape[0]
+ if n_verts == 0:
+ raise ValueError("save_glb: vertices is empty")
+ if faces_signed.size > 0:
+ fmin = int(faces_signed.min())
+ fmax = int(faces_signed.max())
+ if fmin < 0 or fmax >= n_verts:
+ raise ValueError(
+ f"save_glb: face index out of range [0, {n_verts}): min={fmin}, max={fmax}"
+ )
+ if uvs_np is not None and uvs_np.shape[0] != n_verts:
+ raise ValueError(
+ f"save_glb: uvs has {uvs_np.shape[0]} entries but vertex count is {n_verts}"
+ )
+ if colors_np is not None and colors_np.shape[0] != n_verts:
+ raise ValueError(
+ f"save_glb: vertex_colors has {colors_np.shape[0]} entries but vertex count is {n_verts}"
+ )
+ faces_np = faces_signed.astype(np.uint32)
+ texture_png_bytes = None
+ if texture_image is not None:
+ buf = BytesIO()
+ texture_image.save(buf, format="PNG")
+ texture_png_bytes = buf.getvalue()
+
+ vertices_buffer = vertices_np.tobytes()
+ indices_buffer = faces_np.tobytes()
+ uvs_buffer = uvs_np.tobytes() if uvs_np is not None else b""
+ colors_buffer = colors_np.tobytes() if colors_np is not None else b""
+ texture_buffer = texture_png_bytes if texture_png_bytes is not None else b""
+
+ def pad_to_4_bytes(buffer):
+ padding_length = (4 - (len(buffer) % 4)) % 4
+ return buffer + b'\x00' * padding_length
+
+ vertices_buffer_padded = pad_to_4_bytes(vertices_buffer)
+ indices_buffer_padded = pad_to_4_bytes(indices_buffer)
+ uvs_buffer_padded = pad_to_4_bytes(uvs_buffer)
+ colors_buffer_padded = pad_to_4_bytes(colors_buffer)
+ texture_buffer_padded = pad_to_4_bytes(texture_buffer)
+
+ buffer_data = b"".join([
+ vertices_buffer_padded,
+ indices_buffer_padded,
+ uvs_buffer_padded,
+ colors_buffer_padded,
+ texture_buffer_padded,
+ ])
+
+ vertices_byte_length = len(vertices_buffer)
+ vertices_byte_offset = 0
+ indices_byte_length = len(indices_buffer)
+ indices_byte_offset = len(vertices_buffer_padded)
+ uvs_byte_offset = indices_byte_offset + len(indices_buffer_padded)
+ colors_byte_offset = uvs_byte_offset + len(uvs_buffer_padded)
+ texture_byte_offset = colors_byte_offset + len(colors_buffer_padded)
+
+ buffer_views = [
+ {
+ "buffer": 0,
+ "byteOffset": vertices_byte_offset,
+ "byteLength": vertices_byte_length,
+ "target": 34962 # ARRAY_BUFFER
+ },
+ {
+ "buffer": 0,
+ "byteOffset": indices_byte_offset,
+ "byteLength": indices_byte_length,
+ "target": 34963 # ELEMENT_ARRAY_BUFFER
+ }
+ ]
+ accessors = [
+ {
+ "bufferView": 0,
+ "byteOffset": 0,
+ "componentType": 5126, # FLOAT
+ "count": len(vertices_np),
+ "type": "VEC3",
+ "max": vertices_np.max(axis=0).tolist(),
+ "min": vertices_np.min(axis=0).tolist()
+ },
+ {
+ "bufferView": 1,
+ "byteOffset": 0,
+ "componentType": 5125, # UNSIGNED_INT
+ "count": faces_np.size,
+ "type": "SCALAR"
+ }
+ ]
+ primitive_attributes = {"POSITION": 0}
+
+ if uvs_np is not None and len(uvs_np) > 0:
+ buffer_views.append({
+ "buffer": 0,
+ "byteOffset": uvs_byte_offset,
+ "byteLength": len(uvs_buffer),
+ "target": 34962
+ })
+ accessor_idx = len(accessors)
+ accessors.append({
+ "bufferView": len(buffer_views) - 1,
+ "byteOffset": 0,
+ "componentType": 5126,
+ "count": len(uvs_np),
+ "type": "VEC2",
+ })
+ primitive_attributes["TEXCOORD_0"] = accessor_idx
+
+ if colors_np is not None and len(colors_np) > 0:
+ buffer_views.append({
+ "buffer": 0,
+ "byteOffset": colors_byte_offset,
+ "byteLength": len(colors_buffer),
+ "target": 34962
+ })
+ accessor_idx = len(accessors)
+ accessors.append({
+ "bufferView": len(buffer_views) - 1,
+ "byteOffset": 0,
+ "componentType": 5126,
+ "count": len(colors_np),
+ "type": "VEC3" if colors_np.shape[1] == 3 else "VEC4",
+ })
+ primitive_attributes["COLOR_0"] = accessor_idx
+
+ primitive = {
+ "attributes": primitive_attributes,
+ "indices": 1,
+ "mode": 4 # TRIANGLES
+ }
+
+ images = []
+ textures = []
+ samplers = []
+ materials = []
+ if texture_png_bytes is not None and "TEXCOORD_0" in primitive_attributes:
+ buffer_views.append({
+ "buffer": 0,
+ "byteOffset": texture_byte_offset,
+ "byteLength": len(texture_buffer),
+ })
+ images.append({"bufferView": len(buffer_views) - 1, "mimeType": "image/png"})
+ samplers.append({"magFilter": 9729, "minFilter": 9729, "wrapS": 33071, "wrapT": 33071})
+ textures.append({"source": 0, "sampler": 0})
+ materials.append({
+ "pbrMetallicRoughness": {
+ "baseColorTexture": {"index": 0, "texCoord": 0},
+ "metallicFactor": 0.0,
+ "roughnessFactor": 1.0,
+ },
+ "doubleSided": True,
+ })
+ primitive["material"] = 0
+
+ gltf = {
+ "asset": {"version": "2.0", "generator": "ComfyUI"},
+ "buffers": [{"byteLength": len(buffer_data)}],
+ "bufferViews": buffer_views,
+ "accessors": accessors,
+ "meshes": [{"primitives": [primitive]}],
+ "nodes": [{"mesh": 0}],
+ "scenes": [{"nodes": [0]}],
+ "scene": 0,
+ }
+ if images:
+ gltf["images"] = images
+ if samplers:
+ gltf["samplers"] = samplers
+ if textures:
+ gltf["textures"] = textures
+ if materials:
+ gltf["materials"] = materials
+
+ if metadata:
+ gltf["asset"]["extras"] = metadata
+
+ # Convert the JSON to bytes
+ gltf_json = json.dumps(gltf).encode('utf8')
+
+ def pad_json_to_4_bytes(buffer):
+ padding_length = (4 - (len(buffer) % 4)) % 4
+ return buffer + b' ' * padding_length
+
+ gltf_json_padded = pad_json_to_4_bytes(gltf_json)
+
+ # Create the GLB header (a 4-byte ASCII magic identifier glTF)
+ glb_header = struct.pack('<4sII', b'glTF', 2, 12 + 8 + len(gltf_json_padded) + 8 + len(buffer_data))
+
+ # Create JSON chunk header (chunk type 0)
+ json_chunk_header = struct.pack('<II', len(gltf_json_padded), 0x4E4F534A) # "JSON" in little endian
+
+ # Create BIN chunk header (chunk type 1)
+ bin_chunk_header = struct.pack('<II', len(buffer_data), 0x004E4942) # "BIN\0" in little endian
+
+ # Write the GLB file
+ with open(filepath, 'wb') as f:
+ f.write(glb_header)
+ f.write(json_chunk_header)
+ f.write(gltf_json_padded)
+ f.write(bin_chunk_header)
+ f.write(buffer_data)
+
+ return filepath
+
+
+class SaveGLB(IO.ComfyNode):
+ @classmethod
+ def define_schema(cls):
+ return IO.Schema(
+ node_id="SaveGLB",
+ display_name="Save 3D Model",
+ search_aliases=["export 3d model", "save mesh"],
+ category="3d",
+ essentials_category="Basics",
+ is_output_node=True,
+ inputs=[
+ IO.MultiType.Input(
+ IO.Mesh.Input("mesh"),
+ types=[
+ IO.File3DGLB,
+ IO.File3DGLTF,
+ IO.File3DOBJ,
+ IO.File3DFBX,
+ IO.File3DSTL,
+ IO.File3DUSDZ,
+ IO.File3DAny,
+ ],
+ tooltip="Mesh or 3D file to save",
+ ),
+ IO.String.Input("filename_prefix", default="3d/ComfyUI"),
+ ],
+ hidden=[IO.Hidden.prompt, IO.Hidden.extra_pnginfo]
+ )
+
+ @classmethod
+ def execute(cls, mesh: Types.MESH | Types.File3D, filename_prefix: str) -> IO.NodeOutput:
+ full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, folder_paths.get_output_directory())
+ results = []
+
+ metadata = {}
+ if not args.disable_metadata:
+ if cls.hidden.prompt is not None:
+ metadata["prompt"] = json.dumps(cls.hidden.prompt)
+ if cls.hidden.extra_pnginfo is not None:
+ for x in cls.hidden.extra_pnginfo:
+ metadata[x] = json.dumps(cls.hidden.extra_pnginfo[x])
+
+ if isinstance(mesh, Types.File3D):
+ # Handle File3D input - save BytesIO data to output folder
+ ext = mesh.format or "glb"
+ f = f"{filename}_{counter:05}_.{ext}"
+ mesh.save_to(os.path.join(full_output_folder, f))
+ results.append({
+ "filename": f,
+ "subfolder": subfolder,
+ "type": "output"
+ })
+ counter += 1
+ else:
+ # Handle Mesh input - save vertices and faces as GLB; carry optional UVs / colors / texture.
+ texture_b = getattr(mesh, "texture", None)
+ texture_np = None
+ if texture_b is not None:
+ texture_np = (texture_b.clamp(0.0, 1.0).cpu().numpy() * 255).astype(np.uint8)
+ assert texture_np.ndim == 4 and texture_np.shape[-1] == 3, (
+ f"texture must be (B, H, W, 3) RGB, got shape {tuple(texture_np.shape)}"
+ )
+ for i in range(mesh.vertices.shape[0]):
+ vertices_i, faces_i, v_colors, uvs_i = get_mesh_batch_item(mesh, i)
+ if vertices_i.shape[0] == 0 or faces_i.shape[0] == 0:
+ logging.warning(f"SaveGLB: skipping empty mesh at batch index {i}")
+ continue
+ tex_img = Image.fromarray(texture_np[i], mode="RGB") if texture_np is not None else None
+ f = f"{filename}_{counter:05}_.glb"
+ save_glb(vertices_i, faces_i, os.path.join(full_output_folder, f), metadata,
+ uvs=uvs_i,
+ vertex_colors=v_colors,
+ texture_image=tex_img)
+ results.append({
+ "filename": f,
+ "subfolder": subfolder,
+ "type": "output"
+ })
+ counter += 1
+ return IO.NodeOutput(ui={"3d": results})
+
+
+class Save3DExtension(ComfyExtension):
+ @override
+ async def get_node_list(self) -> list[type[IO.ComfyNode]]:
+ return [SaveGLB]
+
+
+async def comfy_entrypoint() -> Save3DExtension:
+ return Save3DExtension()
diff --git a/nodes.py b/nodes.py
index 78aaaef74..2b63f9fbb 100644
--- a/nodes.py
+++ b/nodes.py
@@ -2436,6 +2436,7 @@ async def init_builtin_extra_nodes():
"nodes_void.py",
"nodes_wandancer.py",
"nodes_hidream_o1.py",
+ "nodes_save_3d.py",
]
import_failed = []