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.

[Partner Nodes] add new Rodin2.5 nodes (#14051)

Alexander Piskun1579bbb52de5
diff --git a/comfy_api_nodes/apis/rodin.py b/comfy_api_nodes/apis/rodin.py
index fc26a6e73..24524d642 100644
--- a/comfy_api_nodes/apis/rodin.py
+++ b/comfy_api_nodes/apis/rodin.py
@@ -1,7 +1,5 @@
-from __future__ import annotations
-
from enum import Enum
-from typing import Optional, List
+
from pydantic import BaseModel, Field
@@ -11,44 +9,76 @@ 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: Optional[bool] = Field(None, description="")
+ 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"].')
+
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: 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")
+ 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")
+
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):
- list: List[RodinResourceItem] = Field(..., description="Source List")
+ items: list[RodinResourceItem] = Field(..., alias="list", description="Source List")
diff --git a/comfy_api_nodes/nodes_rodin.py b/comfy_api_nodes/nodes_rodin.py
index 2b829b8db..2df5a3e13 100644
--- a/comfy_api_nodes/nodes_rodin.py
+++ b/comfy_api_nodes/nodes_rodin.py
@@ -5,32 +5,37 @@ 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_extensions import override
+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 comfy_api_nodes.apis.rodin import (
- Rodin3DGenerateRequest,
- Rodin3DGenerateResponse,
+ JobStatus,
Rodin3DCheckStatusRequest,
Rodin3DCheckStatusResponse,
Rodin3DDownloadRequest,
Rodin3DDownloadResponse,
- JobStatus,
+ Rodin3DGen25Request,
+ Rodin3DGenerateRequest,
+ Rodin3DGenerateResponse,
)
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(
@@ -51,40 +56,30 @@ COMMON_PARAMETERS = [
]
-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
+_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: str) -> tuple[str, int]:
+ """Map a polygon-count preset like '18K-Quad' to (mesh_mode, quality_override).
- return 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.
@@ -96,8 +91,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
@@ -112,7 +107,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
@@ -145,11 +140,9 @@ 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",
)
@@ -177,6 +170,7 @@ def check_rodin_status(response: Rodin3DCheckStatusResponse) -> str:
return "DONE"
return "Generating"
+
def extract_progress(response: Rodin3DCheckStatusResponse) -> int | None:
if not response.jobs:
return None
@@ -214,7 +208,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.list:
+ for i in url_list.items:
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)
@@ -489,7 +483,16 @@ 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,
),
@@ -542,6 +545,566 @@ 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]]:
@@ -551,6 +1114,8 @@ class Rodin3DExtension(ComfyExtension):
Rodin3D_Smooth,
Rodin3D_Sketch,
Rodin3D_Gen2,
+ Rodin3D_Gen25_Image,
+ Rodin3D_Gen25_Text,
]