CORE-225 add File3DToMesh node and PBR material props for MESH

.github/workflows/backport_release.yaml

@@ -458,41 +458,6 @@ jobs:
 
           echo "Released ${NEW_VERSION} on ${RELEASE_BRANCH}."
 
-      - name: Delete remote source branch
-        env:
-          GH_TOKEN:        ${{ steps.app-token.outputs.token }}
-          REPO:            ${{ github.repository }}
-          SOURCE_BRANCH:   ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:   ${{ inputs.commit }}
-          RELEASE_BRANCH:  ${{ steps.latest.outputs.release_branch }}
-          DEFAULT_BRANCH:  ${{ github.event.repository.default_branch }}
-        run: |
-          set -euo pipefail
-
-          # Belt-and-braces: the resolve step already refuses the default branch,
-          # but never delete the default or the release branch under any
-          # circumstances.
-          if [[ "${SOURCE_BRANCH}" == "${DEFAULT_BRANCH}" || "${SOURCE_BRANCH}" == "${RELEASE_BRANCH}" ]]; then
-            echo "::error::Refusing to delete '${SOURCE_BRANCH}' (matches default or release branch)."
-            exit 1
-          fi
-
-          # Delete the source branch on origin, but only if its tip is still the
-          # SHA we released from. If someone pushed new commits to it after we
-          # resolved it, leave it alone — those commits would be silently lost.
-          current_tip="$(git ls-remote origin "refs/heads/${SOURCE_BRANCH}" | awk '{print $1}')"
-          if [[ -z "${current_tip}" ]]; then
-            echo "Source branch '${SOURCE_BRANCH}' no longer exists on origin; nothing to delete."
-            exit 0
-          fi
-          if [[ "${current_tip}" != "${SOURCE_COMMIT}" ]]; then
-            echo "::warning::Source branch '${SOURCE_BRANCH}' tip (${current_tip}) no longer matches released commit (${SOURCE_COMMIT}). Leaving it in place."
-            exit 0
-          fi
-
-          git push origin --delete "refs/heads/${SOURCE_BRANCH}"
-          echo "Deleted remote branch '${SOURCE_BRANCH}'."
-
       - name: Summary
         if: always()
         env:

comfy_api/latest/_util/geometry_types.py

@@ -17,7 +17,8 @@ class MESH:
                  vertex_colors: torch.Tensor | None = None,
                  texture: torch.Tensor | None = None,
                  vertex_counts: torch.Tensor | None = None,
-                 face_counts: torch.Tensor | None = None):
+                 face_counts: torch.Tensor | None = None,
+                 material_props: dict | None = None):
 
         assert (vertex_counts is None) == (face_counts is None), \
             "vertex_counts and face_counts must be provided together (both or neither)"
@@ -30,6 +31,7 @@ class MESH:
         # 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
+        self.material_props = material_props
 
 
 class File3D:

comfy_api_nodes/apis/rodin.py

@@ -1,5 +1,7 @@
-from enum import Enum
+from __future__ import annotations
 
+from enum import Enum
+from typing import Optional, List
 from pydantic import BaseModel, Field
 
 
@@ -9,76 +11,44 @@ class Rodin3DGenerateRequest(BaseModel):
     material: str = Field(..., description="The material type.")
     quality_override: int = Field(..., description="The poly count of the mesh.")
     mesh_mode: str = Field(..., description="It controls the type of faces of generated models.")
-    TAPose: bool | None = Field(None, description="")
-
-
-class Rodin3DGen25Request(BaseModel):
-
-    tier: str = Field(..., description="Gen-2.5 tier (e.g. Gen-2.5-High).")
-    prompt: str | None = Field(None, description="Required for Text-to-3D; ignored otherwise.")
-    seed: int | None = Field(None, description="0-65535.")
-    material: str | None = Field(None, description="PBR | Shaded | All | None.")
-    geometry_file_format: str | None = Field(None, description="glb | usdz | fbx | obj | stl.")
-    texture_mode: str | None = Field(None, description="legacy | extreme-low | low | medium | high.")
-    mesh_mode: str | None = Field(None, description="Raw (triangular) | Quad.")
-    quality_override: int | None = Field(None, description="Mesh face count override.")
-    geometry_instruct_mode: str | None = Field(None, description="faithful | creative.")
-    bbox_condition: list[int] | None = Field(None, description="Bounding box [Width(Y), Height(Z), Length(X)] in cm.")
-    height: int | None = Field(None, description="Approximate model height in cm.")
-    TAPose: bool | None = Field(None, description="T/A pose for human-like models.")
-    hd_texture: bool | None = Field(None, description="Enhanced texture quality.")
-    texture_delight: bool | None = Field(None, description="Remove baked lighting from textures.")
-    is_micro: bool | None = Field(None, description="Micro detail (Extreme-High only).")
-    use_original_alpha: bool | None = Field(None, description="Preserve image transparency.")
-    preview_render: bool | None = Field(None, description="Generate high-quality preview render.")
-    addons: list[str] | None = Field(None, description='Optional addons, e.g. ["HighPack"].')
-
+    TAPose: Optional[bool] = Field(None, description="")
 
 class GenerateJobsData(BaseModel):
-    uuids: list[str] = Field(..., description="str LIST")
+    uuids: List[str] = Field(..., description="str LIST")
     subscription_key: str = Field(..., description="subscription key")
 
-
 class Rodin3DGenerateResponse(BaseModel):
-    message: str | None = Field(None, description="Return message.")
-    prompt: str | None = Field(None, description="Generated Prompt from image.")
-    submit_time: str | None = Field(None, description="Submit Time")
-    uuid: str | None = Field(None, description="Task str")
-    jobs: GenerateJobsData | None = Field(None, description="Details of jobs")
-
+    message: Optional[str] = Field(None, description="Return message.")
+    prompt: Optional[str] = Field(None, description="Generated Prompt from image.")
+    submit_time: Optional[str] = Field(None, description="Submit Time")
+    uuid: Optional[str] = Field(None, description="Task str")
+    jobs: Optional[GenerateJobsData] = Field(None, description="Details of jobs")
 
 class JobStatus(str, Enum):
     """
     Status for jobs
     """
-
     Done = "Done"
     Failed = "Failed"
     Generating = "Generating"
     Waiting = "Waiting"
 
-
 class Rodin3DCheckStatusRequest(BaseModel):
     subscription_key: str = Field(..., description="subscription from generate endpoint")
 
-
 class JobItem(BaseModel):
     uuid: str = Field(..., description="uuid")
-    status: JobStatus = Field(..., description="Status Currently")
-
+    status: JobStatus = Field(...,description="Status Currently")
 
 class Rodin3DCheckStatusResponse(BaseModel):
-    jobs: list[JobItem] = Field(..., description="Job status List")
-
+    jobs: List[JobItem] = Field(..., description="Job status List")
 
 class Rodin3DDownloadRequest(BaseModel):
     task_uuid: str = Field(..., description="Task str")
 
-
 class RodinResourceItem(BaseModel):
     url: str = Field(..., description="Download Url")
     name: str = Field(..., description="File name with ext")
 
-
 class Rodin3DDownloadResponse(BaseModel):
-    items: list[RodinResourceItem] = Field(..., alias="list", description="Source List")
+    list: List[RodinResourceItem] = Field(..., description="Source List")

comfy_api_nodes/nodes_rodin.py

@@ -5,37 +5,32 @@ Rodin API docs: https://developer.hyper3d.ai/
 
 """
 
+from inspect import cleandoc
+import folder_paths as comfy_paths
+import os
 import logging
 import math
-import os
-from inspect import cleandoc
 from io import BytesIO
-from typing import Any
-
-import aiohttp
-from PIL import Image
 from typing_extensions import override
-
-import folder_paths as comfy_paths
-from comfy_api.latest import IO, ComfyExtension, Types
+from PIL import Image
 from comfy_api_nodes.apis.rodin import (
-    JobStatus,
+    Rodin3DGenerateRequest,
+    Rodin3DGenerateResponse,
     Rodin3DCheckStatusRequest,
     Rodin3DCheckStatusResponse,
     Rodin3DDownloadRequest,
     Rodin3DDownloadResponse,
-    Rodin3DGen25Request,
-    Rodin3DGenerateRequest,
-    Rodin3DGenerateResponse,
+    JobStatus,
 )
 from comfy_api_nodes.util import (
+    sync_op,
+    poll_op,
     ApiEndpoint,
     download_url_to_bytesio,
     download_url_to_file_3d,
-    poll_op,
-    sync_op,
-    validate_string,
 )
+from comfy_api.latest import ComfyExtension, IO, Types
+
 
 COMMON_PARAMETERS = [
     IO.Int.Input(
@@ -56,30 +51,40 @@ COMMON_PARAMETERS = [
 ]
 
 
-_QUALITY_MESH_OPTIONS: dict[str, tuple[str, int]] = {
-    "4K-Quad":       ("Quad", 4000),
-    "8K-Quad":       ("Quad", 8000),
-    "18K-Quad":      ("Quad", 18000),
-    "50K-Quad":      ("Quad", 50000),
-    "200K-Quad":     ("Quad", 200000),
-    "2K-Triangle":   ("Raw", 2000),
-    "20K-Triangle":  ("Raw", 20000),
-    "150K-Triangle": ("Raw", 150000),
-    "200K-Triangle": ("Raw", 200000),
-    "500K-Triangle": ("Raw", 500000),
-    "1M-Triangle":   ("Raw", 1000000),
-}
+def get_quality_mode(poly_count):
+    polycount = poly_count.split("-")
+    poly = polycount[1]
+    count = polycount[0]
+    if poly == "Triangle":
+        mesh_mode = "Raw"
+    elif poly == "Quad":
+        mesh_mode = "Quad"
+    else:
+        mesh_mode = "Quad"
+
+    if count == "4K":
+        quality_override = 4000
+    elif count == "8K":
+        quality_override = 8000
+    elif count == "18K":
+        quality_override = 18000
+    elif count == "50K":
+        quality_override = 50000
+    elif count == "2K":
+        quality_override = 2000
+    elif count == "20K":
+        quality_override = 20000
+    elif count == "150K":
+        quality_override = 150000
+    elif count == "500K":
+        quality_override = 500000
+    else:
+        quality_override = 18000
+
+    return mesh_mode, quality_override
 
 
-def get_quality_mode(poly_count: str) -> tuple[str, int]:
-    """Map a polygon-count preset like '18K-Quad' to (mesh_mode, quality_override).
-
-    Falls back to ('Quad', 18000) for unknown labels; legacy parity.
-    """
-    return _QUALITY_MESH_OPTIONS.get(poly_count, ("Quad", 18000))
-
-
-def tensor_to_filelike(tensor, max_pixels: int = 2048 * 2048):
+def tensor_to_filelike(tensor, max_pixels: int = 2048*2048):
     """
     Converts a PyTorch tensor to a file-like object.
 
@@ -91,8 +96,8 @@ def tensor_to_filelike(tensor, max_pixels: int = 2048 * 2048):
     - io.BytesIO: A file-like object containing the image data.
     """
     array = tensor.cpu().numpy()
-    array = (array * 255).astype("uint8")
-    image = Image.fromarray(array, "RGB")
+    array = (array * 255).astype('uint8')
+    image = Image.fromarray(array, 'RGB')
 
     original_width, original_height = image.size
     original_pixels = original_width * original_height
@@ -107,7 +112,7 @@ def tensor_to_filelike(tensor, max_pixels: int = 2048 * 2048):
         image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
 
     img_byte_arr = BytesIO()
-    image.save(img_byte_arr, format="PNG")  # PNG is used for lossless compression
+    image.save(img_byte_arr, format='PNG')  # PNG is used for lossless compression
     img_byte_arr.seek(0)
     return img_byte_arr
 
@@ -140,9 +145,11 @@ async def create_generate_task(
             TAPose=ta_pose,
         ),
         files=[
-            ("images", open(image, "rb") if isinstance(image, str) else tensor_to_filelike(image))
-            for image in images
-            if image is not None
+            (
+                "images",
+                open(image, "rb") if isinstance(image, str) else tensor_to_filelike(image)
+            )
+            for image in images if image is not None
         ],
         content_type="multipart/form-data",
     )
@@ -170,7 +177,6 @@ def check_rodin_status(response: Rodin3DCheckStatusResponse) -> str:
         return "DONE"
     return "Generating"
 
-
 def extract_progress(response: Rodin3DCheckStatusResponse) -> int | None:
     if not response.jobs:
         return None
@@ -208,7 +214,7 @@ async def download_files(url_list, task_uuid: str) -> tuple[str | None, Types.Fi
     model_file_path = None
     file_3d = None
 
-    for i in url_list.items:
+    for i in url_list.list:
         file_path = os.path.join(save_path, i.name)
         if i.name.lower().endswith(".glb"):
             model_file_path = os.path.join(result_folder_name, i.name)
@@ -483,16 +489,7 @@ class Rodin3D_Gen2(IO.ComfyNode):
                 IO.Combo.Input("Material_Type", options=["PBR", "Shaded"], default="PBR", optional=True),
                 IO.Combo.Input(
                     "Polygon_count",
-                    options=[
-                        "4K-Quad",
-                        "8K-Quad",
-                        "18K-Quad",
-                        "50K-Quad",
-                        "2K-Triangle",
-                        "20K-Triangle",
-                        "150K-Triangle",
-                        "500K-Triangle",
-                    ],
+                    options=["4K-Quad", "8K-Quad", "18K-Quad", "50K-Quad", "2K-Triangle", "20K-Triangle", "150K-Triangle", "500K-Triangle"],
                     default="500K-Triangle",
                     optional=True,
                 ),
@@ -545,566 +542,6 @@ class Rodin3D_Gen2(IO.ComfyNode):
         return IO.NodeOutput(model_path, file_3d)
 
 
-def _rodin_multipart_parser(data: dict[str, Any]) -> aiohttp.FormData:
-    """Convert a Rodin request dict to an aiohttp form, fixing bool/list serialization.
-
-    Booleans --> "true"/"false". Lists --> one field per element.
-    """
-    form = aiohttp.FormData(default_to_multipart=True)
-    for key, value in data.items():
-        if value is None:
-            continue
-        if isinstance(value, bool):
-            form.add_field(key, "true" if value else "false")
-        elif isinstance(value, list):
-            for item in value:
-                form.add_field(key, str(item))
-        elif isinstance(value, (bytes, bytearray)):
-            form.add_field(key, value)
-        else:
-            form.add_field(key, str(value))
-    return form
-
-
-async def _create_gen25_task(
-    cls: type[IO.ComfyNode],
-    request: Rodin3DGen25Request,
-    images: list | None,
-) -> tuple[str, str]:
-    """Submit a Gen-2.5 generate job; returns (task_uuid, subscription_key)."""
-
-    if images is not None and len(images) > 5:
-        raise ValueError("Rodin Gen-2.5 supports at most 5 input images.")
-
-    files = None
-    if images:
-        files = [
-            (
-                "images",
-                open(image, "rb") if isinstance(image, str) else tensor_to_filelike(image),
-            )
-            for image in images
-            if image is not None
-        ]
-
-    response = await sync_op(
-        cls,
-        ApiEndpoint(path="/proxy/rodin/api/v2/rodin", method="POST"),
-        response_model=Rodin3DGenerateResponse,
-        data=request,
-        files=files,
-        content_type="multipart/form-data",
-        multipart_parser=_rodin_multipart_parser,
-    )
-
-    if not response.uuid or not response.jobs or not response.jobs.subscription_key:
-        raise RuntimeError(f"Rodin Gen-2.5 submit failed: message={response.message!r}")
-    return response.uuid, response.jobs.subscription_key
-
-
-_PREVIEWABLE_3D_EXTS = {".glb", ".obj", ".fbx", ".stl", ".gltf"}
-
-
-async def _download_gen25_files(
-    download_list: Rodin3DDownloadResponse,
-    task_uuid: str,
-    geometry_file_format: str,
-) -> Types.File3D | None:
-    """Download every file in the list; return the File3D matching the chosen format."""
-
-    folder_name = f"Rodin3D_Gen25_{task_uuid}"
-    save_dir = os.path.join(comfy_paths.get_output_directory(), folder_name)
-    os.makedirs(save_dir, exist_ok=True)
-
-    target_ext = f".{geometry_file_format.lower().lstrip('.')}"
-    file_3d: Types.File3D | None = None
-
-    for item in download_list.items:
-        file_path = os.path.join(save_dir, item.name)
-        ext = os.path.splitext(item.name.lower())[1]
-        # Prefer the file matching the user's chosen format; fall back below.
-        if file_3d is None and ext == target_ext and ext in _PREVIEWABLE_3D_EXTS:
-            file_3d = await download_url_to_file_3d(item.url, target_ext.lstrip("."))
-            with open(file_path, "wb") as f:
-                f.write(file_3d.get_bytes())
-            continue
-        await download_url_to_bytesio(item.url, file_path)
-
-    # If the chosen format wasn't found, surface any model file we did get.
-    if file_3d is None:
-        for item in download_list.items:
-            ext = os.path.splitext(item.name.lower())[1]
-            if ext in _PREVIEWABLE_3D_EXTS:
-                file_3d = await download_url_to_file_3d(item.url, ext.lstrip("."))
-                break
-    return file_3d
-
-
-_MODE_REGULAR = "Regular"
-_MODE_FAST = "Fast"
-_MODE_EXTREME_HIGH = "Extreme-High"
-
-_REGULAR_POLY_OPTIONS = [
-    "Default",
-    "4K-Quad",
-    "8K-Quad",
-    "18K-Quad",
-    "50K-Quad",
-    "2K-Triangle",
-    "20K-Triangle",
-    "150K-Triangle",
-    "500K-Triangle",
-    "1M-Triangle",
-]
-
-_TEXTURE_MODE_OPTIONS = ["Default", "legacy", "extreme-low", "low", "medium", "high"]
-_GEOMETRY_FORMAT_OPTIONS = ["glb", "fbx", "obj", "stl"]
-_MATERIAL_OPTIONS = ["PBR", "Shaded", "All", "None"]
-
-
-def _build_mode_input(name: str = "mode") -> IO.DynamicCombo.Input:
-    return IO.DynamicCombo.Input(
-        name,
-        options=[
-            IO.DynamicCombo.Option(
-                _MODE_REGULAR,
-                [
-                    IO.Combo.Input(
-                        "tier",
-                        options=["Gen-2.5-Low", "Gen-2.5-Medium", "Gen-2.5-High"],
-                        default="Gen-2.5-High",
-                        tooltip="Quality tier. Higher tiers produce higher-fidelity geometry.",
-                    ),
-                    IO.Combo.Input(
-                        "polygon_count",
-                        options=_REGULAR_POLY_OPTIONS,
-                        default="Default",
-                        tooltip="Preset face count. 'Default' uses the server's default for the selected tier.",
-                    ),
-                    IO.Boolean.Input(
-                        "creative",
-                        default=False,
-                        tooltip="Creative mode (Medium/High only). Enhances generative robustness.",
-                    ),
-                ],
-            ),
-            IO.DynamicCombo.Option(
-                _MODE_FAST,
-                [
-                    IO.Combo.Input(
-                        "tier",
-                        options=[
-                            "Gen-2.5-Extreme-Low",
-                            "Gen-2.5-Low",
-                            "Gen-2.5-Medium",
-                            "Gen-2.5-High",
-                        ],
-                        default="Gen-2.5-Low",
-                    ),
-                    IO.Int.Input(
-                        "mesh_faces",
-                        default=20000,
-                        min=1000,
-                        max=20000,
-                        display_mode=IO.NumberDisplay.number,
-                        tooltip="Mesh face count (1K-20K in Fast mode).",
-                    ),
-                ],
-            ),
-            IO.DynamicCombo.Option(
-                _MODE_EXTREME_HIGH,
-                [
-                    IO.Combo.Input("mesh_mode", options=["Raw", "Quad"], default="Raw"),
-                    IO.Int.Input(
-                        "mesh_faces",
-                        default=1000000,
-                        min=20000,
-                        max=2000000,
-                        display_mode=IO.NumberDisplay.number,
-                        tooltip=(
-                            "Mesh face count. Raw mode: 20K-2M. "
-                            "Quad mode: keep under 200K (upstream may reject higher values)."
-                        ),
-                    ),
-                    IO.Boolean.Input(
-                        "is_micro",
-                        default=False,
-                        tooltip="Enable micro detail (Extreme-High only).",
-                    ),
-                    IO.Boolean.Input(
-                        "creative",
-                        default=False,
-                        tooltip="Creative mode. Enhances generative robustness.",
-                    ),
-                ],
-            ),
-        ],
-        tooltip=(
-            "Generation mode. Regular = balanced. Fast = 1K-20K faces for rapid prototyping. "
-            "Extreme-High = 20K-2M faces with optional micro details."
-        ),
-    )
-
-
-def _build_common_inputs(*, include_image_only: bool) -> list:
-    inputs: list = [
-        IO.Combo.Input("material", options=_MATERIAL_OPTIONS, default="Shaded"),
-        IO.Combo.Input("geometry_file_format", options=_GEOMETRY_FORMAT_OPTIONS, default="glb"),
-        IO.Combo.Input(
-            "texture_mode",
-            options=_TEXTURE_MODE_OPTIONS,
-            default="Default",
-            optional=True,
-            tooltip="Texture quality preset. 'Default' uses the server's default for the selected tier.",
-        ),
-        IO.Int.Input(
-            "seed",
-            default=0,
-            min=0,
-            max=65535,
-            display_mode=IO.NumberDisplay.number,
-            control_after_generate=True,
-            optional=True,
-        ),
-        IO.Boolean.Input(
-            "TAPose", default=False, optional=True, advanced=True, tooltip="T/A pose for human-like models."
-        ),
-        IO.Boolean.Input(
-            "hd_texture", default=False, optional=True, advanced=True, tooltip="High-quality texture enhancement."
-        ),
-        IO.Boolean.Input(
-            "texture_delight",
-            default=False,
-            optional=True,
-            advanced=True,
-            tooltip="Remove baked lighting from textures.",
-        ),
-    ]
-    if include_image_only:
-        inputs.append(
-            IO.Boolean.Input(
-                "use_original_alpha",
-                default=False,
-                optional=True,
-                advanced=True,
-                tooltip="Preserve image transparency.",
-            )
-        )
-    inputs.extend(
-        [
-            IO.Boolean.Input(
-                "addon_highpack",
-                default=False,
-                optional=True,
-                advanced=True,
-                tooltip="HighPack addon: 4K textures and ~16x faces in Quad mode.",
-            ),
-            IO.Int.Input(
-                "bbox_width",
-                default=0,
-                min=0,
-                max=300,
-                display_mode=IO.NumberDisplay.number,
-                optional=True,
-                advanced=True,
-                tooltip="Bounding-box width (Y axis). Set to 0 with the others to skip bbox.",
-            ),
-            IO.Int.Input(
-                "bbox_height",
-                default=0,
-                min=0,
-                max=300,
-                display_mode=IO.NumberDisplay.number,
-                optional=True,
-                advanced=True,
-                tooltip="Bounding-box height (Z axis).",
-            ),
-            IO.Int.Input(
-                "bbox_length",
-                default=0,
-                min=0,
-                max=300,
-                display_mode=IO.NumberDisplay.number,
-                optional=True,
-                advanced=True,
-                tooltip="Bounding-box length (X axis).",
-            ),
-            IO.Int.Input(
-                "height_cm",
-                default=0,
-                min=0,
-                max=10000,
-                display_mode=IO.NumberDisplay.number,
-                optional=True,
-                advanced=True,
-                tooltip="Approximate model height in centimeters (0 to skip).",
-            ),
-        ]
-    )
-    return inputs
-
-
-_PRICE_EXPR = """
-(
-  $baseCredits := widgets.mode = "extreme-high" ? 1.0 : 0.5;
-  $addonCredits := widgets.addon_highpack ? 1.0 : 0.0;
-  $total := ($baseCredits * 1.5) + ($addonCredits * 0.8);
-  {"type":"usd","usd": $total}
-)
-"""
-
-
-def _resolve_mode_params(mode_input: dict) -> dict:
-    """Translate the DynamicCombo `mode` payload into Gen-2.5 request fields.
-
-    Returns a dict with: tier, quality_override, mesh_mode, geometry_instruct_mode, is_micro.
-    Missing keys mean "do not send" (so we don't override server defaults).
-    """
-    selected = mode_input["mode"]
-    out: dict = {}
-
-    if selected == _MODE_REGULAR:
-        out["tier"] = mode_input["tier"]
-        polygon = mode_input.get("polygon_count", "Default")
-        if polygon != "Default":
-            mesh_mode, faces = get_quality_mode(polygon)
-            out["mesh_mode"] = mesh_mode
-            out["quality_override"] = faces
-        if mode_input.get("creative"):
-            out["geometry_instruct_mode"] = "creative"
-
-    elif selected == _MODE_FAST:
-        out["tier"] = mode_input["tier"]
-        out["mesh_mode"] = "Raw"
-        out["quality_override"] = int(mode_input["mesh_faces"])
-
-    elif selected == _MODE_EXTREME_HIGH:
-        out["tier"] = "Gen-2.5-Extreme-High"
-        out["mesh_mode"] = mode_input["mesh_mode"]
-        out["quality_override"] = int(mode_input["mesh_faces"])
-        if mode_input.get("is_micro"):
-            out["is_micro"] = True
-        if mode_input.get("creative"):
-            out["geometry_instruct_mode"] = "creative"
-    return out
-
-
-def _build_request(
-    *,
-    mode_input: dict,
-    material: str,
-    geometry_file_format: str,
-    texture_mode: str,
-    seed: int,
-    TAPose: bool,
-    hd_texture: bool,
-    texture_delight: bool,
-    addon_highpack: bool,
-    bbox_width: int,
-    bbox_height: int,
-    bbox_length: int,
-    height_cm: int,
-    prompt: str | None = None,
-    use_original_alpha: bool = False,
-) -> Rodin3DGen25Request:
-    mode_params = _resolve_mode_params(mode_input)
-
-    bbox = None
-    if bbox_width and bbox_height and bbox_length:
-        bbox = [bbox_width, bbox_height, bbox_length]
-
-    return Rodin3DGen25Request(
-        tier=mode_params["tier"],
-        prompt=prompt or None,
-        seed=seed,
-        material=material,
-        geometry_file_format=geometry_file_format,
-        texture_mode=None if texture_mode == "Default" else texture_mode,
-        mesh_mode=mode_params.get("mesh_mode"),
-        quality_override=mode_params.get("quality_override"),
-        geometry_instruct_mode=mode_params.get("geometry_instruct_mode"),
-        bbox_condition=bbox,
-        height=height_cm or None,
-        TAPose=TAPose or None,
-        hd_texture=hd_texture or None,
-        texture_delight=texture_delight or None,
-        is_micro=mode_params.get("is_micro"),
-        use_original_alpha=use_original_alpha or None,
-        addons=["HighPack"] if addon_highpack else None,
-    )
-
-
-class Rodin3D_Gen25_Image(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls) -> IO.Schema:
-        return IO.Schema(
-            node_id="Rodin3D_Gen25_Image",
-            display_name="Rodin 3D Gen-2.5 - Image to 3D",
-            category="api node/3d/Rodin",
-            description=(
-                "Generate a 3D model from 1-5 reference images via Rodin Gen-2.5. "
-                "Pick a mode (Fast / Regular / Extreme-High) to tune quality vs. cost."
-            ),
-            inputs=[
-                IO.Autogrow.Input(
-                    "images",
-                    template=IO.Autogrow.TemplatePrefix(IO.Image.Input("image"), prefix="image", min=1, max=5),
-                    tooltip="1-5 images. The first image is used for materials when multi-view.",
-                ),
-                _build_mode_input(),
-                *_build_common_inputs(include_image_only=True),
-            ],
-            outputs=[IO.File3DAny.Output(display_name="model_file")],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode", "addon_highpack"]),
-                expr=_PRICE_EXPR,
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        images: IO.Autogrow.Type,
-        mode: dict,
-        material: str,
-        geometry_file_format: str,
-        texture_mode: str,
-        seed: int,
-        TAPose: bool,
-        hd_texture: bool,
-        texture_delight: bool,
-        use_original_alpha: bool,
-        addon_highpack: bool,
-        bbox_width: int,
-        bbox_height: int,
-        bbox_length: int,
-        height_cm: int,
-    ) -> IO.NodeOutput:
-        image_tensors = [img for img in images.values() if img is not None]
-        if not image_tensors:
-            raise ValueError("Rodin Gen-2.5 Image-to-3D requires at least one image.")
-
-        # Flatten multi-image tensors into individual frames; the API accepts each as a separate part.
-        flat_images: list = []
-        for tensor in image_tensors:
-            if hasattr(tensor, "shape") and len(tensor.shape) == 4:
-                for i in range(tensor.shape[0]):
-                    flat_images.append(tensor[i])
-            else:
-                flat_images.append(tensor)
-
-        if len(flat_images) > 5:
-            raise ValueError(f"Rodin Gen-2.5 accepts at most 5 images; received {len(flat_images)}.")
-
-        request = _build_request(
-            mode_input=mode,
-            material=material,
-            geometry_file_format=geometry_file_format,
-            texture_mode=texture_mode,
-            seed=seed,
-            TAPose=TAPose,
-            hd_texture=hd_texture,
-            texture_delight=texture_delight,
-            addon_highpack=addon_highpack,
-            bbox_width=bbox_width,
-            bbox_height=bbox_height,
-            bbox_length=bbox_length,
-            height_cm=height_cm,
-            prompt=None,
-            use_original_alpha=use_original_alpha,
-        )
-
-        task_uuid, subscription_key = await _create_gen25_task(cls, request, flat_images)
-        await poll_for_task_status(subscription_key, cls)
-        download_list = await get_rodin_download_list(task_uuid, cls)
-        file_3d = await _download_gen25_files(download_list, task_uuid, geometry_file_format)
-        return IO.NodeOutput(file_3d)
-
-
-class Rodin3D_Gen25_Text(IO.ComfyNode):
-
-    @classmethod
-    def define_schema(cls) -> IO.Schema:
-        return IO.Schema(
-            node_id="Rodin3D_Gen25_Text",
-            display_name="Rodin 3D Gen-2.5 - Text to 3D",
-            category="api node/3d/Rodin",
-            description=(
-                "Generate a 3D model from a text prompt via Rodin Gen-2.5. "
-                "Pick a mode (Fast / Regular / Extreme-High) to tune quality vs. cost."
-            ),
-            inputs=[
-                IO.String.Input(
-                    "prompt",
-                    multiline=True,
-                    default="",
-                    tooltip="Text prompt for the 3D model.",
-                ),
-                _build_mode_input(),
-                *_build_common_inputs(include_image_only=False),
-            ],
-            outputs=[IO.File3DAny.Output(display_name="model_file")],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(widgets=["mode", "addon_highpack"]),
-                expr=_PRICE_EXPR,
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        prompt: str,
-        mode: dict,
-        material: str,
-        geometry_file_format: str,
-        texture_mode: str,
-        seed: int,
-        TAPose: bool,
-        hd_texture: bool,
-        texture_delight: bool,
-        addon_highpack: bool,
-        bbox_width: int,
-        bbox_height: int,
-        bbox_length: int,
-        height_cm: int,
-    ) -> IO.NodeOutput:
-        validate_string(prompt, field_name="prompt", min_length=1, max_length=2500)
-        request = _build_request(
-            mode_input=mode,
-            material=material,
-            geometry_file_format=geometry_file_format,
-            texture_mode=texture_mode,
-            seed=seed,
-            TAPose=TAPose,
-            hd_texture=hd_texture,
-            texture_delight=texture_delight,
-            addon_highpack=addon_highpack,
-            bbox_width=bbox_width,
-            bbox_height=bbox_height,
-            bbox_length=bbox_length,
-            height_cm=height_cm,
-            prompt=prompt,
-        )
-        task_uuid, subscription_key = await _create_gen25_task(cls, request, images=None)
-        await poll_for_task_status(subscription_key, cls)
-        download_list = await get_rodin_download_list(task_uuid, cls)
-        file_3d = await _download_gen25_files(download_list, task_uuid, geometry_file_format)
-        return IO.NodeOutput(file_3d)
-
-
 class Rodin3DExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -1114,8 +551,6 @@ class Rodin3DExtension(ComfyExtension):
             Rodin3D_Smooth,
             Rodin3D_Sketch,
             Rodin3D_Gen2,
-            Rodin3D_Gen25_Image,
-            Rodin3D_Gen25_Text,
         ]
 
 

comfy_extras/nodes_load_3d.py

@@ -3,15 +3,141 @@ import folder_paths
 import os
 import uuid
 
+import numpy as np
+import torch
 from typing_extensions import override
 from comfy_api.latest import IO, UI, ComfyExtension, InputImpl, Types
 
 from pathlib import Path
 
+_SUPPORTED_MESH_FORMATS = {"glb", "obj"}
+
 
 def normalize_path(path):
     return path.replace('\\', '/')
 
+
+def _normalize_color_factor(value, length: int):
+    # trimesh stores baseColorFactor/emissiveFactor as either uint8 (0-255) or float (0-1).
+    # glTF spec values are float [0, 1]; normalize here.
+    arr = np.asarray(value, dtype=np.float64).reshape(-1)
+    if arr.size < length:
+        return None
+    arr = arr[:length]
+    if np.issubdtype(np.asarray(value).dtype, np.integer) or arr.max() > 1.0 + 1e-6:
+        arr = arr / 255.0
+    return tuple(float(x) for x in np.clip(arr, 0.0, 1.0))
+
+
+def _extract_material_props(material) -> dict | None:
+    if material is None:
+        return None
+    props: dict = {}
+
+    bcf = getattr(material, "baseColorFactor", None)
+    if bcf is not None:
+        v = _normalize_color_factor(bcf, 4)
+        if v is not None:
+            props["base_color_factor"] = v
+    ef = getattr(material, "emissiveFactor", None)
+    if ef is not None:
+        v = _normalize_color_factor(ef, 3)
+        if v is not None:
+            props["emissive_factor"] = v
+    for src_attr, dst_key in (
+        ("metallicFactor", "metallic_factor"),
+        ("roughnessFactor", "roughness_factor"),
+        ("alphaCutoff", "alpha_cutoff"),
+    ):
+        v = getattr(material, src_attr, None)
+        if v is not None:
+            props[dst_key] = float(v)
+    ds = getattr(material, "doubleSided", None)
+    if ds is not None:
+        props["double_sided"] = bool(ds)
+    am = getattr(material, "alphaMode", None)
+    if am is not None:
+        props["alpha_mode"] = getattr(am, "name", None) or str(am)
+
+    if "base_color_factor" not in props:
+        # SimpleMaterial.diffuse always exists and defaults to [102, 102, 102, 255]
+        # (40% gray) even when the source MTL doesn't declare Kd. Compare against the
+        # trimesh default to avoid silently darkening textures that only specified map_Kd.
+        diffuse = getattr(material, "diffuse", None)
+        if diffuse is not None:
+            d_arr = np.asarray(diffuse)
+            is_default = (d_arr.dtype == np.uint8 and d_arr.shape == (4,)
+                          and bool(np.array_equal(d_arr, [102, 102, 102, 255])))
+            if not is_default:
+                v = _normalize_color_factor(diffuse, 4)
+                if v is not None:
+                    props["base_color_factor"] = v
+
+    return props or None
+
+
+def _file3d_to_mesh(file_3d: Types.File3D) -> Types.MESH:
+    import trimesh
+
+    fmt = (file_3d.format or "").lower()
+    if fmt not in _SUPPORTED_MESH_FORMATS:
+        raise ValueError(
+            f"File3DToMesh only supports {sorted(_SUPPORTED_MESH_FORMATS)}, got '.{fmt}'"
+        )
+
+    source = file_3d.get_source() if file_3d.is_disk_backed else file_3d.get_data()
+    loaded = trimesh.load(source, file_type=fmt, process=False)
+
+    if isinstance(loaded, trimesh.Scene):
+        geometries = [g for g in loaded.dump(concatenate=False) if isinstance(g, trimesh.Trimesh)]
+        if not geometries:
+            raise ValueError("File3DToMesh: scene contains no triangle meshes")
+        mesh = trimesh.util.concatenate(geometries) if len(geometries) > 1 else geometries[0]
+    elif isinstance(loaded, trimesh.Trimesh):
+        mesh = loaded
+    else:
+        raise ValueError(f"File3DToMesh: unsupported geometry type '{type(loaded).__name__}'")
+
+    if len(mesh.faces) == 0:
+        raise ValueError("File3DToMesh: mesh has no faces (point clouds are not supported)")
+
+    vertices = torch.from_numpy(np.ascontiguousarray(mesh.vertices, dtype=np.float32)).unsqueeze(0)
+    faces = torch.from_numpy(np.ascontiguousarray(mesh.faces, dtype=np.int64)).unsqueeze(0)
+    n_verts = vertices.shape[1]
+
+    uvs = None
+    vertex_colors = None
+    texture = None
+    material_props = None
+
+    visual = getattr(mesh, "visual", None)
+    if visual is not None:
+        uv = getattr(visual, "uv", None)
+        if uv is not None and len(uv) == n_verts:
+            uvs = torch.from_numpy(np.ascontiguousarray(uv, dtype=np.float32)).unsqueeze(0)
+
+        try:
+            vc = getattr(visual, "vertex_colors", None)
+        except (AttributeError, ValueError, KeyError):
+            vc = None
+        if vc is not None and len(vc) == n_verts:
+            vc_arr = np.asarray(vc, dtype=np.float32) / 255.0
+            if vc_arr.ndim == 2 and vc_arr.shape[1] >= 3:
+                vc_arr = vc_arr[:, :4] if vc_arr.shape[1] >= 4 else vc_arr[:, :3]
+                vertex_colors = torch.from_numpy(np.ascontiguousarray(vc_arr)).unsqueeze(0)
+
+        material = getattr(visual, "material", None)
+        if material is not None:
+            tex_img = getattr(material, "baseColorTexture", None) or getattr(material, "image", None)
+            if tex_img is not None:
+                tex_np = np.asarray(tex_img.convert("RGB"), dtype=np.float32) / 255.0
+                texture = torch.from_numpy(np.ascontiguousarray(tex_np)).unsqueeze(0)
+            material_props = _extract_material_props(material)
+
+    return Types.MESH(vertices, faces, uvs=uvs, vertex_colors=vertex_colors,
+                      texture=texture, material_props=material_props)
+
+
 class Load3D(IO.ComfyNode):
     @classmethod
     def define_schema(cls):
@@ -118,12 +244,39 @@ class Preview3D(IO.ComfyNode):
     process = execute  # TODO: remove
 
 
+class File3DToMesh(IO.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return IO.Schema(
+            node_id="File3DToMesh",
+            display_name="File3D to Mesh",
+            search_aliases=["parse 3d file", "load mesh"],
+            category="3d",
+            is_experimental=True,
+            inputs=[
+                IO.MultiType.Input(
+                    IO.File3DAny.Input("file_3d"),
+                    types=[IO.File3DGLB, IO.File3DOBJ],
+                    tooltip="3D file to parse into a MESH (.glb or .obj only)",
+                ),
+            ],
+            outputs=[
+                IO.Mesh.Output(),
+            ],
+        )
+
+    @classmethod
+    def execute(cls, file_3d: Types.File3D) -> IO.NodeOutput:
+        return IO.NodeOutput(_file3d_to_mesh(file_3d))
+
+
 class Load3DExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
         return [
             Load3D,
             Preview3D,
+            File3DToMesh,
         ]
 
 

comfy_extras/nodes_logic.py

@@ -91,7 +91,7 @@ class SwitchNode(io.ComfyNode):
         return io.Schema(
             node_id="ComfySwitchNode",
             display_name="Switch",
-            category="utils/logic",
+            category="logic",
             is_experimental=True,
             inputs=[
                 io.Boolean.Input("switch"),
@@ -122,7 +122,7 @@ class SoftSwitchNode(io.ComfyNode):
         return io.Schema(
             node_id="ComfySoftSwitchNode",
             display_name="Soft Switch",
-            category="utils/logic",
+            category="logic",
             is_experimental=True,
             inputs=[
                 io.Boolean.Input("switch"),
@@ -212,7 +212,7 @@ class DCTestNode(io.ComfyNode):
         return io.Schema(
             node_id="DCTestNode",
             display_name="DCTest",
-            category="utils/logic",
+            category="logic",
             is_output_node=True,
             inputs=[io.DynamicCombo.Input("combo", options=[
                 io.DynamicCombo.Option("option1", [io.String.Input("string")]),
@@ -250,7 +250,7 @@ class AutogrowNamesTestNode(io.ComfyNode):
         return io.Schema(
             node_id="AutogrowNamesTestNode",
             display_name="AutogrowNamesTest",
-            category="utils/logic",
+            category="logic",
             inputs=[
                 _io.Autogrow.Input("autogrow", template=template)
             ],
@@ -270,7 +270,7 @@ class AutogrowPrefixTestNode(io.ComfyNode):
         return io.Schema(
             node_id="AutogrowPrefixTestNode",
             display_name="AutogrowPrefixTest",
-            category="utils/logic",
+            category="logic",
             inputs=[
                 _io.Autogrow.Input("autogrow", template=template)
             ],
@@ -289,7 +289,7 @@ class ComboOutputTestNode(io.ComfyNode):
         return io.Schema(
             node_id="ComboOptionTestNode",
             display_name="ComboOptionTest",
-            category="utils/logic",
+            category="logic",
             inputs=[io.Combo.Input("combo", options=["option1", "option2", "option3"]),
                     io.Combo.Input("combo2", options=["option4", "option5", "option6"])],
             outputs=[io.Combo.Output(), io.Combo.Output()],
@@ -306,7 +306,7 @@ class ConvertStringToComboNode(io.ComfyNode):
             node_id="ConvertStringToComboNode",
             search_aliases=["string to dropdown", "text to combo"],
             display_name="Convert String to Combo",
-            category="utils/logic",
+            category="logic",
             inputs=[io.String.Input("string")],
             outputs=[io.Combo.Output()],
         )
@@ -322,7 +322,7 @@ class InvertBooleanNode(io.ComfyNode):
             node_id="InvertBooleanNode",
             search_aliases=["not", "toggle", "negate", "flip boolean"],
             display_name="Invert Boolean",
-            category="utils/logic",
+            category="logic",
             inputs=[io.Boolean.Input("boolean")],
             outputs=[io.Boolean.Output()],
         )

comfy_extras/nodes_math.py

@@ -70,7 +70,7 @@ class MathExpressionNode(io.ComfyNode):
         return io.Schema(
             node_id="ComfyMathExpression",
             display_name="Math Expression",
-            category="utils",
+            category="logic",
             search_aliases=[
                 "expression", "formula", "calculate", "calculator",
                 "eval", "math",

comfy_extras/nodes_save_3d.py

@@ -16,11 +16,12 @@ 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):
+def pack_variable_mesh_batch(vertices, faces, colors=None, uvs=None, texture=None, material_props=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
+    # material_props is shared across the batch — 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)
@@ -54,7 +55,8 @@ def pack_variable_mesh_batch(vertices, faces, colors=None, uvs=None, texture=Non
 
     return Types.MESH(packed_vertices, packed_faces,
                       uvs=packed_uvs, vertex_colors=packed_colors, texture=texture,
-                      vertex_counts=vertex_counts, face_counts=face_counts)
+                      vertex_counts=vertex_counts, face_counts=face_counts,
+                      material_props=material_props)
 
 
 def get_mesh_batch_item(mesh, index):
@@ -77,7 +79,8 @@ def get_mesh_batch_item(mesh, index):
 
 
 def save_glb(vertices, faces, filepath, metadata=None,
-             uvs=None, vertex_colors=None, texture_image=None):
+             uvs=None, vertex_colors=None, texture_image=None,
+             material_props=None):
     """
     Save PyTorch tensor vertices and faces as a GLB file without external dependencies.
 
@@ -86,15 +89,25 @@ def save_glb(vertices, faces, filepath, metadata=None,
     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
+    uvs: torch.Tensor of shape (N, 2) - Optional per-vertex texture coordinates in OpenGL/trimesh
+                                        convention (V=0 at bottom of texture). save_glb flips V
+                                        to satisfy the glTF spec convention (V=0 at top) on disk.
     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
+    material_props: dict - Optional PBR factors
     """
 
     # 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
+    if uvs_np is not None:
+        # MESH stores UVs with V=0 at the bottom of the texture (OpenGL / trimesh / OBJ
+        # convention). glTF stores V=0 at the top of the texture. Flip V here so the
+        # written GLB renders correctly in spec-compliant viewers (Three.js, glTF Sample
+        # Viewer, etc.). Copy first to avoid mutating the caller's tensor-backed array.
+        uvs_np = uvs_np.copy()
+        uvs_np[:, 1] = 1.0 - uvs_np[:, 1]
     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)
@@ -234,23 +247,53 @@ def save_glb(vertices, faces, filepath, metadata=None,
     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,
-        })
+    write_texture = texture_png_bytes is not None and "TEXCOORD_0" in primitive_attributes
+    if write_texture or material_props:
+        pbr: dict = {}
+        material: dict = {"pbrMetallicRoughness": pbr}
+
+        if write_texture:
+            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})
+            pbr["baseColorTexture"] = {"index": 0, "texCoord": 0}
+
+        if material_props is None:
+            # Legacy default: matte plastic, double-sided. Kept for backward compatibility
+            # with producers (e.g., VoxelToMesh) that never carried PBR factors.
+            if write_texture:
+                pbr["metallicFactor"] = 0.0
+                pbr["roughnessFactor"] = 1.0
+                material["doubleSided"] = True
+        else:
+            bcf = material_props.get("base_color_factor")
+            if bcf is not None:
+                pbr["baseColorFactor"] = [float(x) for x in bcf]
+            mf = material_props.get("metallic_factor")
+            if mf is not None:
+                pbr["metallicFactor"] = float(mf)
+            rf = material_props.get("roughness_factor")
+            if rf is not None:
+                pbr["roughnessFactor"] = float(rf)
+            ef = material_props.get("emissive_factor")
+            if ef is not None:
+                material["emissiveFactor"] = [float(x) for x in ef]
+            ds = material_props.get("double_sided")
+            if ds is not None:
+                material["doubleSided"] = bool(ds)
+            am = material_props.get("alpha_mode")
+            if am is not None:
+                material["alphaMode"] = str(am)
+            ac = material_props.get("alpha_cutoff")
+            if ac is not None:
+                material["alphaCutoff"] = float(ac)
+
+        materials.append(material)
         primitive["material"] = 0
 
     gltf = {
@@ -358,7 +401,7 @@ class SaveGLB(IO.ComfyNode):
             })
             counter += 1
         else:
-            # Handle Mesh input - save vertices and faces as GLB; carry optional UVs / colors / texture.
+            # Handle Mesh input - save vertices and faces as GLB; carry optional UVs / colors / texture / material props.
             texture_b = getattr(mesh, "texture", None)
             texture_np = None
             if texture_b is not None:
@@ -366,6 +409,7 @@ class SaveGLB(IO.ComfyNode):
                 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)}"
                 )
+            material_props = getattr(mesh, "material_props", None)
             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:
@@ -376,7 +420,8 @@ class SaveGLB(IO.ComfyNode):
                 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)
+                         texture_image=tex_img,
+                         material_props=material_props)
                 results.append({
                     "filename": f,
                     "subfolder": subfolder,

comfy_extras/nodes_toolkit.py

@@ -14,7 +14,7 @@ class CreateList(io.ComfyNode):
         return io.Schema(
             node_id="CreateList",
             display_name="Create List",
-            category="utils",
+            category="logic",
             is_input_list=True,
             search_aliases=["Image Iterator", "Text Iterator", "Iterator"],
             inputs=[io.Autogrow.Input("inputs", template=template_autogrow)],

requirements.txt

@@ -35,3 +35,4 @@ pydantic~=2.0
 pydantic-settings~=2.0
 PyOpenGL
 glfw
+trimesh>=4.0