import json from pathlib import Path from urllib.parse import urlparse from typing_extensions import override from comfy_api.latest import IO, ComfyExtension, Input, Types from comfy_api_nodes.apis.tripo import ( TRIPO_BIPED_ANIMATIONS, TripoAnimatePrerigcheckRequest, TripoAnimateRetargetRequest, TripoAnimation, TripoAnimateRigRequest, TripoConvertModelRequest, TripoEditMultiviewImageRequest, TripoFileEmptyReference, TripoFileReference, TripoGenerateMultiviewImageRequest, TripoHighpolyToLowpolyRequest, TripoImageToModelRequest, TripoImportModelRequest, TripoMeshCompletionRequest, TripoMeshSegmentationRequest, TripoModelVersion, TripoMultiviewEditPrompt, TripoMultiviewToModelRequest, TripoOrientation, TripoOutFormat, TripoP1ImageToModelRequest, TripoP1MultiviewToModelRequest, TripoP1TextToModelRequest, TripoRigModelVersion, TripoRigType, TripoSpec, TripoStyle, TripoTaskResponse, TripoTaskStatus, TripoTaskType, TripoTextToModelRequest, TripoTextureModelRequest, TripoTextureModelVersion, TripoTexturePrompt, TripoUrlReference, ) from comfy_api_nodes.util import ( ApiEndpoint, download_url_to_file_3d, download_url_to_image_tensor, poll_op, sync_op, upload_3d_model_to_comfyapi, upload_images_to_comfyapi, ) MULTIVIEW_KEYS = ("front_view_url", "left_view_url", "back_view_url", "right_view_url") SEED_MAX = 2**31 - 1 TEXTURE_SOURCE_TYPES_WITH_IMAGE = ("text_to_model", "image_to_model", "multiview_to_model", "texture_model") FACE_LIMIT_TOOLTIP = ( "Maximum face count. -1 lets Tripo pick adaptively (about 1.4M faces on v3.x standard, 2M on detailed). " "Tripo clamps silently: v2.5 at 500,000, quad meshes at 150,000." ) def get_model_url_from_response(response: TripoTaskResponse) -> str: if response.data is not None: for key in ["pbr_model", "model", "base_model"]: if getattr(response.data.output, key, None) is not None: return getattr(response.data.output, key) raise RuntimeError(f"Failed to get model url from response: {response}") async def poll_task( node_cls: type[IO.ComfyNode], response: TripoTaskResponse, average_duration: int | None = None, ) -> TripoTaskResponse: """Polls the Tripo API endpoint until the task reaches a terminal state, then returns the response.""" if response.code != 0: raise RuntimeError(f"Failed to create Tripo task: {response}") response_poll = await poll_op( node_cls, poll_endpoint=ApiEndpoint(path=f"/proxy/tripo/v2/openapi/task/{response.data.task_id}"), response_model=TripoTaskResponse, completed_statuses=[TripoTaskStatus.SUCCESS], failed_statuses=[ TripoTaskStatus.FAILED, TripoTaskStatus.CANCELLED, TripoTaskStatus.UNKNOWN, TripoTaskStatus.BANNED, TripoTaskStatus.EXPIRED, ], status_extractor=lambda x: x.data.status, progress_extractor=lambda x: x.data.progress, estimated_duration=average_duration, ) if response_poll.data.status != TripoTaskStatus.SUCCESS: raise RuntimeError(f"Tripo task failed: {response_poll}") return response_poll async def poll_until_finished( node_cls: type[IO.ComfyNode], response: TripoTaskResponse, average_duration: int | None = None, ) -> tuple[str, Types.File3D]: """Polls the Tripo API endpoint until the task reaches a terminal state, then downloads the model.""" response_poll = await poll_task(node_cls, response, average_duration) task_id = response_poll.data.task_id url = get_model_url_from_response(response_poll) file_format = Path(urlparse(url).path).suffix.lstrip(".").lower() or "glb" return task_id, await download_url_to_file_3d(url, file_format, task_id=task_id) async def check_riggable(node_cls: type[IO.ComfyNode], model_task_id: str) -> tuple[bool, str]: response = await sync_op( node_cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoAnimatePrerigcheckRequest(original_model_task_id=model_task_id), ) output = (await poll_task(node_cls, response, average_duration=5)).data.output return bool(output.riggable), output.rig_type or output.topology or "" async def upload_image_reference(node_cls: type[IO.ComfyNode], image: Input.Image) -> TripoFileReference: url = (await upload_images_to_comfyapi(node_cls, image, max_images=1))[0] return TripoFileReference(root=TripoUrlReference(url=url, type="jpeg")) async def multiview_output(node_cls: type[IO.ComfyNode], response: TripoTaskResponse, with_task_id: bool) -> IO.NodeOutput: response_poll = await poll_task(node_cls, response, average_duration=25) views = response_poll.data.output.generate_multiview_image or {} if any(not views.get(key) for key in MULTIVIEW_KEYS): raise RuntimeError(f"Tripo returned incomplete multiview images: {response_poll}") images = [await download_url_to_image_tensor(views[key], cls=node_cls) for key in MULTIVIEW_KEYS] return IO.NodeOutput(response_poll.data.task_id, *images) if with_task_id else IO.NodeOutput(*images) def part_names_from_glb(model: Types.File3D) -> list[str]: data = model.get_bytes() if data[:4] != b"glTF": return [] chunk_length = int.from_bytes(data[12:16], "little") document = json.loads(data[20 : 20 + chunk_length]) return [node["name"] for node in document.get("nodes", []) if node.get("name")] def split_part_names(part_names: str) -> list[str] | None: return list(dict.fromkeys(name.strip() for name in part_names.split(",") if name.strip())) or None def glb_output(task_id: str, model: Types.File3D) -> IO.NodeOutput: if model.format != "glb": raise RuntimeError(f"Tripo returned a {model.format.upper()} file where GLB was expected") return IO.NodeOutput(f"{task_id}.glb", task_id, model) def check_smart_low_poly_face_limit(smart_low_poly: bool | None, face_limit: int | None, quad: bool | None) -> None: if smart_low_poly and face_limit not in (None, -1) and not 500 <= face_limit <= (10000 if quad else 20000): raise ValueError( "With smart_low_poly, face_limit must be between 500 and 20,000 for triangles or 500 and 10,000 for quads." ) def glb_or_fbx_output(task_id: str, model: Types.File3D) -> IO.NodeOutput: if model.format not in ("glb", "fbx"): raise RuntimeError(f"Tripo returned a file of type {model.format.upper() or 'unknown'} where GLB or FBX was expected") return IO.NodeOutput( f"{task_id}.{model.format}", task_id, model if model.format == "glb" else None, model if model.format == "fbx" else None, ) class TripoTextToModelNode(IO.ComfyNode): """ Generates 3D models synchronously based on a text prompt using Tripo's API. """ @classmethod def define_schema(cls): return IO.Schema( node_id="TripoTextToModelNode", display_name="Tripo: Text to Model", category="partner/3d/Tripo", inputs=[ IO.String.Input("prompt", multiline=True), IO.String.Input("negative_prompt", multiline=True, optional=True, tooltip="Up to 255 characters."), IO.Combo.Input( "model_version", options=TripoModelVersion, default=TripoModelVersion.v3_1_20260211, optional=True ), IO.Combo.Input( "style", options=TripoStyle, default="None", optional=True, tooltip="No longer supported by Tripo and ignored. Kept for older workflows.", ), IO.Boolean.Input( "texture", default=True, optional=True, tooltip="Generate texture maps. Off returns bare geometry and ignores pbr.", ), IO.Boolean.Input( "pbr", default=True, optional=True, tooltip="PBR material maps (base color, metallic, roughness, normal). Requires texture.", ), IO.Int.Input("image_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Int.Input("model_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Int.Input("texture_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Combo.Input( "texture_quality", default="standard", options=["standard", "detailed", "extreme"], optional=True, advanced=True, tooltip="detailed = HD textures, extreme = 8K Ultra textures.", ), IO.Int.Input("face_limit", default=-1, min=-1, max=2000000, optional=True, advanced=True, tooltip=FACE_LIMIT_TOOLTIP), IO.Boolean.Input( "quad", default=False, optional=True, advanced=True, tooltip="Quad mesh output. Tripo delivers quad meshes as FBX, so the result " "arrives on the FBX output and the GLB output stays empty.", ), IO.Combo.Input( "geometry_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True, ), IO.Boolean.Input( "smart_low_poly", default=False, optional=True, advanced=True, tooltip="Low-poly mesh with clean, hand-crafted style topology (500-20,000 faces, quad 500-10,000). " "Best for simple subjects; complex ones may fail.", ), IO.Boolean.Input( "auto_size", default=True, optional=True, advanced=True, tooltip="Scale textured models to their real-world size in meters. Tripo stores the size as the model's " "scene transform and bakes it in when the model is converted, rigged or retargeted; ignored without texture.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB", tooltip="Empty when quad is enabled."), IO.File3DFBX.Output(display_name="FBX", tooltip="Only populated when quad is enabled."), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( depends_on=IO.PriceBadgeDepends( widgets=[ "model_version", "texture", "quad", "smart_low_poly", "texture_quality", "geometry_quality", ], ), expr=""" ( $isV3OrLater := $contains(widgets.model_version,"v3."); $tq := widgets.texture_quality; $textureAddon := widgets.texture ? ($tq = "extreme" ? 20 : ($tq = "detailed" ? 10 : 0)) : 0; $geometryAddon := (widgets.geometry_quality = "detailed" and $isV3OrLater) ? 20 : 0; $credits := (widgets.texture ? 20 : 10) + (widgets.quad ? 5 : 0) + (widgets.smart_low_poly ? 10 : 0) + $textureAddon + $geometryAddon; {"type":"usd","usd": $credits * 0.01, "format": {"approximate": true}} ) """, ), ) @classmethod async def execute( cls, prompt: str, negative_prompt: str | None = None, model_version=None, style: str | None = None, texture: bool | None = None, pbr: bool | None = None, image_seed: int | None = None, model_seed: int | None = None, texture_seed: int | None = None, texture_quality: str | None = None, geometry_quality: str | None = None, face_limit: int | None = None, quad: bool | None = None, smart_low_poly: bool | None = None, auto_size: bool = True, ) -> IO.NodeOutput: if not prompt.strip(): raise RuntimeError("Prompt is required") check_smart_low_poly_face_limit(smart_low_poly, face_limit, quad) response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoTextToModelRequest( type=TripoTaskType.TEXT_TO_MODEL, prompt=prompt, negative_prompt=negative_prompt if negative_prompt else None, model_version=model_version, texture=texture, pbr=False if texture is False else pbr, image_seed=image_seed, model_seed=model_seed, texture_seed=texture_seed, texture_quality=texture_quality, face_limit=face_limit if face_limit != -1 else None, geometry_quality=geometry_quality, auto_size=auto_size, quad=quad, smart_low_poly=smart_low_poly, ), ) return glb_or_fbx_output(*await poll_until_finished(cls, response, average_duration=80)) class TripoImageToModelNode(IO.ComfyNode): """ Generates 3D models synchronously based on a single image using Tripo's API. """ @classmethod def define_schema(cls): return IO.Schema( node_id="TripoImageToModelNode", display_name="Tripo: Image to Model", category="partner/3d/Tripo", inputs=[ IO.Image.Input("image"), IO.Combo.Input( "model_version", options=TripoModelVersion, tooltip="The model version to use for generation", optional=True, ), IO.Combo.Input( "style", options=TripoStyle, default="None", optional=True, tooltip="No longer supported by Tripo and ignored. Kept for older workflows.", ), IO.Boolean.Input( "texture", default=True, optional=True, tooltip="Generate texture maps. Off returns bare geometry and ignores pbr.", ), IO.Boolean.Input( "pbr", default=True, optional=True, tooltip="PBR material maps (base color, metallic, roughness, normal). Requires texture.", ), IO.Int.Input("model_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Combo.Input( "orientation", options=TripoOrientation, default=TripoOrientation.DEFAULT, optional=True, advanced=True, ), IO.Int.Input("texture_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Combo.Input( "texture_quality", default="standard", options=["standard", "detailed", "extreme"], optional=True, advanced=True, tooltip="detailed = HD textures, extreme = 8K Ultra textures.", ), IO.Combo.Input( "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True, advanced=True, ), IO.Int.Input("face_limit", default=-1, min=-1, max=2000000, optional=True, advanced=True, tooltip=FACE_LIMIT_TOOLTIP), IO.Boolean.Input( "quad", default=False, optional=True, advanced=True, tooltip="Quad mesh output. Tripo delivers quad meshes as FBX, so the result " "arrives on the FBX output and the GLB output stays empty.", ), IO.Combo.Input( "geometry_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True, ), IO.Boolean.Input( "smart_low_poly", default=False, optional=True, advanced=True, tooltip="Low-poly mesh with clean, hand-crafted style topology (500-20,000 faces, quad 500-10,000). " "Best for simple subjects; complex ones may fail.", ), IO.Boolean.Input( "auto_size", default=True, optional=True, advanced=True, tooltip="Scale textured models to their real-world size in meters. Tripo stores the size as the model's " "scene transform and bakes it in when the model is converted, rigged or retargeted; ignored without texture.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB", tooltip="Empty when quad is enabled."), IO.File3DFBX.Output(display_name="FBX", tooltip="Only populated when quad is enabled."), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( depends_on=IO.PriceBadgeDepends( widgets=[ "model_version", "texture", "quad", "smart_low_poly", "texture_quality", "geometry_quality", ], ), expr=""" ( $isV3OrLater := $contains(widgets.model_version,"v3."); $tq := widgets.texture_quality; $textureAddon := widgets.texture ? ($tq = "extreme" ? 20 : ($tq = "detailed" ? 10 : 0)) : 0; $geometryAddon := (widgets.geometry_quality = "detailed" and $isV3OrLater) ? 20 : 0; $credits := (widgets.texture ? 30 : 20) + (widgets.quad ? 5 : 0) + (widgets.smart_low_poly ? 10 : 0) + $textureAddon + $geometryAddon; {"type":"usd","usd": $credits * 0.01, "format": {"approximate": true}} ) """, ), ) @classmethod async def execute( cls, image: Input.Image, model_version: str | None = None, style: str | None = None, texture: bool | None = None, pbr: bool | None = None, model_seed: int | None = None, orientation=None, texture_seed: int | None = None, texture_quality: str | None = None, geometry_quality: str | None = None, texture_alignment: str | None = None, face_limit: int | None = None, quad: bool | None = None, smart_low_poly: bool | None = None, auto_size: bool = True, ) -> IO.NodeOutput: if image is None: raise RuntimeError("Image is required") check_smart_low_poly_face_limit(smart_low_poly, face_limit, quad) tripo_file = TripoFileReference( root=TripoUrlReference( url=(await upload_images_to_comfyapi(cls, image, max_images=1))[0], type="jpeg", ) ) response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoImageToModelRequest( type=TripoTaskType.IMAGE_TO_MODEL, file=tripo_file, model_version=model_version, texture=texture, pbr=False if texture is False else pbr, model_seed=model_seed, orientation=orientation, geometry_quality=geometry_quality, texture_alignment=texture_alignment, texture_seed=texture_seed, texture_quality=texture_quality, face_limit=face_limit if face_limit != -1 else None, auto_size=auto_size, quad=quad, smart_low_poly=smart_low_poly, ), ) return glb_or_fbx_output(*await poll_until_finished(cls, response, average_duration=80)) class TripoMultiviewToModelNode(IO.ComfyNode): """ Generates 3D models synchronously based on up to four images (front, left, back, right) using Tripo's API. """ @classmethod def define_schema(cls): return IO.Schema( node_id="TripoMultiviewToModelNode", display_name="Tripo: Multiview to Model", category="partner/3d/Tripo", inputs=[ IO.Image.Input("image"), IO.Image.Input("image_left", optional=True), IO.Image.Input("image_back", optional=True), IO.Image.Input("image_right", optional=True), IO.Combo.Input( "model_version", options=TripoModelVersion, optional=True, tooltip="The model version to use for generation", ), IO.Combo.Input( "orientation", options=TripoOrientation, default=TripoOrientation.DEFAULT, optional=True, advanced=True, ), IO.Boolean.Input( "texture", default=True, optional=True, tooltip="Generate texture maps. Off returns bare geometry and ignores pbr.", ), IO.Boolean.Input( "pbr", default=True, optional=True, tooltip="PBR material maps (base color, metallic, roughness, normal). Requires texture.", ), IO.Int.Input("model_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Int.Input("texture_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Combo.Input( "texture_quality", default="standard", options=["standard", "detailed", "extreme"], optional=True, advanced=True, tooltip="detailed = HD textures, extreme = 8K Ultra textures.", ), IO.Combo.Input( "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True, advanced=True, ), IO.Int.Input("face_limit", default=-1, min=-1, max=2000000, optional=True, advanced=True, tooltip=FACE_LIMIT_TOOLTIP), IO.Boolean.Input( "quad", default=False, optional=True, advanced=True, tooltip="Quad mesh output. Tripo delivers quad meshes as FBX, so the result " "arrives on the FBX output and the GLB output stays empty.", ), IO.Combo.Input( "geometry_quality", default="standard", options=["standard", "detailed"], optional=True, advanced=True, ), IO.Boolean.Input( "smart_low_poly", default=False, optional=True, advanced=True, tooltip="Low-poly mesh with clean, hand-crafted style topology (500-20,000 faces, quad 500-10,000). " "Best for simple subjects; complex ones may fail.", ), IO.Boolean.Input( "auto_size", default=False, optional=True, advanced=True, tooltip="Scale textured models to their real-world size in meters. Tripo stores the size as the model's " "scene transform and bakes it in when the model is converted, rigged or retargeted; ignored without texture.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB", tooltip="Empty when quad is enabled."), IO.File3DFBX.Output(display_name="FBX", tooltip="Only populated when quad is enabled."), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( depends_on=IO.PriceBadgeDepends( widgets=[ "model_version", "texture", "quad", "smart_low_poly", "texture_quality", "geometry_quality", ], ), expr=""" ( $isV3OrLater := $contains(widgets.model_version,"v3."); $tq := widgets.texture_quality; $textureAddon := widgets.texture ? ($tq = "extreme" ? 20 : ($tq = "detailed" ? 10 : 0)) : 0; $geometryAddon := (widgets.geometry_quality = "detailed" and $isV3OrLater) ? 20 : 0; $credits := (widgets.texture ? 30 : 20) + (widgets.quad ? 5 : 0) + (widgets.smart_low_poly ? 10 : 0) + $textureAddon + $geometryAddon; {"type":"usd","usd": $credits * 0.01, "format": {"approximate": true}} ) """, ), ) @classmethod async def execute( cls, image: Input.Image, image_left: Input.Image | None = None, image_back: Input.Image | None = None, image_right: Input.Image | None = None, model_version: str | None = None, orientation: str | None = None, texture: bool | None = None, pbr: bool | None = None, model_seed: int | None = None, texture_seed: int | None = None, texture_quality: str | None = None, geometry_quality: str | None = None, texture_alignment: str | None = None, face_limit: int | None = None, quad: bool | None = None, smart_low_poly: bool | None = None, auto_size: bool = False, ) -> IO.NodeOutput: if image is None: raise RuntimeError("front image for multiview is required") images = [] image_dict = {"image": image, "image_left": image_left, "image_back": image_back, "image_right": image_right} if image_left is None and image_back is None and image_right is None: raise RuntimeError("At least one of left, back, or right image must be provided for multiview") check_smart_low_poly_face_limit(smart_low_poly, face_limit, quad) for image_name in ["image", "image_left", "image_back", "image_right"]: image_ = image_dict[image_name] if image_ is not None: images.append( TripoFileReference( root=TripoUrlReference( url=(await upload_images_to_comfyapi(cls, image_, max_images=1))[0], type="jpeg" ) ) ) else: images.append(TripoFileEmptyReference()) response = await sync_op( cls, ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoMultiviewToModelRequest( type=TripoTaskType.MULTIVIEW_TO_MODEL, files=images, model_version=model_version, orientation=orientation, texture=texture, pbr=False if texture is False else pbr, model_seed=model_seed, texture_seed=texture_seed, texture_quality=texture_quality, geometry_quality=geometry_quality, texture_alignment=texture_alignment, face_limit=face_limit if face_limit != -1 else None, auto_size=auto_size, quad=quad, smart_low_poly=smart_low_poly, ), ) return glb_or_fbx_output(*await poll_until_finished(cls, response, average_duration=80)) class TripoImageToMultiviewNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoImageToMultiviewNode", display_name="Tripo: Image to Multiview", category="partner/3d/Tripo", description="Generates front, left, back and right views of the subject. Feed them into " "Tripo: Multiview to Model, or refine them first with Tripo: Edit Multiview.", inputs=[IO.Image.Input("image")], outputs=[ IO.Custom("MULTIVIEW_TASK_ID").Output(display_name="multiview task_id"), IO.Image.Output(display_name="front"), IO.Image.Output(display_name="left"), IO.Image.Output(display_name="back"), IO.Image.Output(display_name="right"), ], 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( expr="""{"type":"usd","usd":0.1, "format": {"approximate": true}}""", ), ) @classmethod async def execute(cls, image: Input.Image) -> IO.NodeOutput: response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoGenerateMultiviewImageRequest(file=await upload_image_reference(cls, image)), ) return await multiview_output(cls, response, with_task_id=True) class TripoEditMultiviewNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoEditMultiviewNode", display_name="Tripo: Edit Multiview", category="partner/3d/Tripo", description="Edits the views of a Tripo: Image to Multiview result with per-view text instructions. " "Views without an instruction stay unchanged. Feed the images into Tripo: Multiview to Model; " "an edited set cannot be edited again.", inputs=[ IO.Custom("MULTIVIEW_TASK_ID").Input("multiview_task_id"), IO.String.Input("front_prompt", default="", multiline=True, optional=True), IO.String.Input("left_prompt", default="", multiline=True, optional=True), IO.String.Input("back_prompt", default="", multiline=True, optional=True), IO.String.Input("right_prompt", default="", multiline=True, optional=True), ], outputs=[ IO.Image.Output(display_name="front"), IO.Image.Output(display_name="left"), IO.Image.Output(display_name="back"), IO.Image.Output(display_name="right"), ], 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=["front_prompt", "left_prompt", "back_prompt", "right_prompt"]), expr=""" ( $prompts := [widgets.front_prompt, widgets.left_prompt, widgets.back_prompt, widgets.right_prompt]; $edited := $count($filter($prompts, function($p) { $length($trim($p)) > 0 })); {"type":"usd","usd": $edited * 0.05, "format": {"approximate": true}} ) """, ), ) @classmethod async def execute( cls, multiview_task_id, front_prompt: str = "", left_prompt: str = "", back_prompt: str = "", right_prompt: str = "", ) -> IO.NodeOutput: views = zip(("front", "left", "back", "right"), (front_prompt, left_prompt, back_prompt, right_prompt)) prompts = [TripoMultiviewEditPrompt(view=view, prompt=prompt.strip()) for view, prompt in views if prompt.strip()] if not prompts: raise ValueError("Provide an edit instruction for at least one view.") response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoEditMultiviewImageRequest(original_task_id=multiview_task_id, prompts=prompts), ) return await multiview_output(cls, response, with_task_id=False) class TripoTextureNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoTextureNode", display_name="Tripo: Texture model", category="partner/3d/Tripo", inputs=[ IO.Custom("MODEL_TASK_ID,SEGMENT_TASK_ID").Input("model_task_id"), IO.Boolean.Input( "texture", default=True, optional=True, tooltip="Ignored: this node always generates textures. Kept for older workflows.", ), IO.Boolean.Input( "pbr", default=True, optional=True, tooltip="PBR material maps (base color, metallic, roughness, normal); off gives a plain color texture.", ), IO.Int.Input("texture_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Combo.Input( "texture_quality", default="standard", options=["standard", "detailed", "extreme"], optional=True, advanced=True, tooltip="detailed = HD textures, extreme = 8K Ultra textures.", ), IO.Combo.Input( "texture_alignment", default="original_image", options=["original_image", "geometry"], optional=True, advanced=True, ), IO.String.Input( "texture_prompt", default="", multiline=True, optional=True, tooltip="Optional text guidance for texturing. Required in practice for imported " "models (Tripo: Import Model), which carry no source image to infer colors from. " "Cannot be combined with reference images.", ), IO.Combo.Input( "model_version", options=TripoTextureModelVersion, default=TripoTextureModelVersion.v3_0_20250812, optional=True, tooltip="Texture model: v3.0 for meshes generated with v3.x, v2.5 for meshes generated with v2.5.", ), IO.Image.Input( "style_image", optional=True, tooltip="Reference image for the artistic style of the textures. Only used together with texture_prompt.", ), IO.DynamicCombo.Input( "reference", options=[ IO.DynamicCombo.Option("none", []), IO.DynamicCombo.Option( "image", [IO.Image.Input("reference_image", tooltip="Single reference image the textures should follow.")], ), IO.DynamicCombo.Option( "multiview", [ IO.Image.Input("image_front", tooltip="Front view (0°)."), IO.Image.Input("image_left", tooltip="Left view (90°)."), IO.Image.Input("image_back", tooltip="Back view (180°)."), IO.Image.Input("image_right", tooltip="Right view (270°)."), ], ), ], optional=True, tooltip="Reference images guiding the textures. Cannot be combined with texture_prompt or style_image.", ), IO.String.Input( "part_names", default="", optional=True, advanced=True, tooltip="Comma-separated part names from Tripo: Segment Model to texture. Empty textures every part.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB", tooltip="Empty when the source is a quad mesh or an FBX import."), IO.File3DFBX.Output( display_name="FBX", tooltip="Tripo returns FBX for quad meshes and FBX imports; empty otherwise.", ), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( depends_on=IO.PriceBadgeDepends(widgets=["texture_quality"]), expr=""" ( $tq := widgets.texture_quality; {"type":"usd","usd": ($tq = "extreme" ? 0.3 : ($tq = "detailed" ? 0.2 : 0.1)), "format": {"approximate": true}} ) """, ), ) @classmethod async def execute( cls, model_task_id, texture: bool | None = None, pbr: bool | None = None, texture_seed: int | None = None, texture_quality: str | None = None, texture_alignment: str | None = None, texture_prompt: str = "", model_version: str | None = None, style_image: Input.Image | None = None, reference: dict | None = None, part_names: str = "", ) -> IO.NodeOutput: text = texture_prompt.strip() mode = reference["reference"] if reference else "none" if mode != "none" and (text or style_image is not None): raise ValueError("Reference images cannot be combined with texture_prompt or style_image.") if style_image is not None and not text: raise ValueError("style_image requires a texture_prompt.") if not text: source = await sync_op( cls, endpoint=ApiEndpoint(path=f"/proxy/tripo/v2/openapi/task/{model_task_id}"), response_model=TripoTaskResponse, ) if source.data.type not in TEXTURE_SOURCE_TYPES_WITH_IMAGE: raise ValueError( "This model has no source image to texture from (imported, segmented, completed or retopologized). " "Give a texture_prompt; Tripo accepts reference images only for models it generated itself." ) if mode == "image": prompt = TripoTexturePrompt(image=await upload_image_reference(cls, reference["reference_image"])) elif mode == "multiview": views = [reference[k] for k in ("image_front", "image_left", "image_back", "image_right")] urls = await upload_images_to_comfyapi(cls, views, max_images=4) prompt = TripoTexturePrompt(images=[TripoFileReference(root=TripoUrlReference(url=u, type="jpeg")) for u in urls]) elif text: prompt = TripoTexturePrompt( text=text, style_image=await upload_image_reference(cls, style_image) if style_image is not None else None, ) else: prompt = None response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoTextureModelRequest( original_model_task_id=model_task_id, model_version=model_version, texture=True, pbr=pbr, texture_seed=texture_seed, texture_quality=texture_quality, texture_alignment=texture_alignment, texture_prompt=prompt, part_names=split_part_names(part_names), ), ) return glb_or_fbx_output(*await poll_until_finished(cls, response, average_duration=80)) class TripoRigNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoRigNode", display_name="Tripo: Rig model", category="partner/3d/Tripo", inputs=[ IO.Custom("MODEL_TASK_ID").Input("original_model_task_id"), IO.Combo.Input( "model_version", options=TripoRigModelVersion, default=TripoRigModelVersion.v1_0_20240301, optional=True, tooltip="v1.0: humanoid (biped) characters only, 90+ animation presets. " "v2.5: non-humanoid creatures (quadruped, hexapod, octopod, avian, serpentine, aquatic).", ), IO.Combo.Input( "rig_type", options=["auto", *[t.value for t in TripoRigType]], default="auto", optional=True, tooltip="Skeleton type. 'auto' runs Tripo's free rig check first and uses the recommended type.", ), IO.Combo.Input( "spec", options=TripoSpec, default=TripoSpec.TRIPO, optional=True, tooltip="Bone naming: Tripo native or Mixamo-compatible. Tripo cannot retarget its animation presets " "onto a v1.0 rig made with the mixamo spec; use tripo for Tripo: Retarget rigged model.", ), IO.Combo.Input( "out_format", options=TripoOutFormat, default=TripoOutFormat.GLB, optional=True, tooltip="Output file format; the result arrives on the matching output.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("RIG_TASK_ID").Output(display_name="rig task_id"), IO.File3DGLB.Output(display_name="GLB", tooltip="Populated when out_format is glb."), IO.File3DFBX.Output(display_name="FBX", tooltip="Populated when out_format is fbx."), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( expr="""{"type":"usd","usd":0.25, "format": {"approximate": true}}""", ), ) @classmethod async def execute( cls, original_model_task_id, model_version: str = "v1.0-20240301", rig_type: str = "auto", spec: str = "tripo", out_format: str = "glb", ) -> IO.NodeOutput: if rig_type == "auto": riggable, rig_type = await check_riggable(cls, original_model_task_id) if not riggable: raise ValueError("Tripo reports that this model cannot be rigged.") if rig_type != "biped" and model_version == "v1.0-20240301": raise ValueError(f"Rig model v1.0-20240301 only supports biped skeletons; use v2.5-20260210 for {rig_type}.") response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoAnimateRigRequest( original_model_task_id=original_model_task_id, model_version=model_version, rig_type=rig_type, out_format=out_format, spec=spec, ), ) return glb_or_fbx_output(*await poll_until_finished(cls, response, average_duration=180)) class TripoRetargetNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoRetargetNode", display_name="Tripo: Retarget rigged model", category="partner/3d/Tripo", inputs=[ IO.Custom("RIG_TASK_ID").Input("original_model_task_id"), IO.Combo.Input( "animation", options=[*[a.value for a in TripoAnimation], *TRIPO_BIPED_ANIMATIONS], tooltip="preset:* animations work with both rig models; " "preset:biped:* animations require a rig made with model v1.0-20240301.", ), IO.Combo.Input( "out_format", options=TripoOutFormat, default=TripoOutFormat.GLB, optional=True, tooltip="Output file format; the result arrives on the matching output.", ), IO.Boolean.Input( "export_with_geometry", default=True, optional=True, advanced=True, tooltip="Include the mesh in the export; off exports the animated skeleton only.", ), IO.Boolean.Input( "animate_in_place", default=False, optional=True, advanced=True, tooltip="Play the animation in place, without root displacement.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("RETARGET_TASK_ID").Output(display_name="retarget task_id"), IO.File3DGLB.Output(display_name="GLB", tooltip="Populated when out_format is glb."), IO.File3DFBX.Output(display_name="FBX", tooltip="Populated when out_format is fbx."), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( expr="""{"type":"usd","usd":0.1, "format": {"approximate": true}}""", ), ) @classmethod async def execute( cls, original_model_task_id, animation: str, out_format: str = "glb", export_with_geometry: bool = True, animate_in_place: bool = False, ) -> IO.NodeOutput: rig = await sync_op( cls, endpoint=ApiEndpoint(path=f"/proxy/tripo/v2/openapi/task/{original_model_task_id}"), response_model=TripoTaskResponse, ) rig_input = rig.data.input or {} if rig_input.get("spec") == "mixamo" and str(rig_input.get("model_version", "")).startswith("v1.0"): raise ValueError("Tripo cannot retarget animation presets onto a v1.0 rig made with the mixamo spec.") response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoAnimateRetargetRequest( original_model_task_id=original_model_task_id, animation=animation, out_format=out_format, export_with_geometry=export_with_geometry, animate_in_place=animate_in_place, ), ) return glb_or_fbx_output(*await poll_until_finished(cls, response, average_duration=30)) class TripoRigCheckNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoRigCheckNode", display_name="Tripo: Rig Check", category="partner/3d/Tripo", description="Checks whether a model can be rigged and which skeleton type Tripo recommends.", inputs=[IO.Custom("MODEL_TASK_ID").Input("model_task_id")], outputs=[ IO.Boolean.Output(display_name="riggable"), IO.String.Output( display_name="rig_type", tooltip="Recommended skeleton: biped, quadruped, hexapod, octopod, avian, serpentine or aquatic; " "'others' when the model is not riggable.", ), ], 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( expr="""{"type":"text","text":"Free"}""", ), ) @classmethod async def execute(cls, model_task_id) -> IO.NodeOutput: riggable, rig_type = await check_riggable(cls, model_task_id) return IO.NodeOutput(riggable, rig_type) class TripoSegmentNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoSegmentNode", display_name="Tripo: Segment Model", category="partner/3d/Tripo", description="Splits a model into parts. The part names feed Tripo: Complete Mesh Parts, " "Tripo: Retopology and Tripo: Convert model.", inputs=[IO.Custom("MODEL_TASK_ID").Input("model_task_id")], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("SEGMENT_TASK_ID").Output(display_name="segment task_id"), IO.File3DGLB.Output(display_name="GLB"), IO.String.Output(display_name="part_names", tooltip="Comma-separated names of the parts."), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( expr="""{"type":"usd","usd":0.4, "format": {"approximate": true}}""", ), ) @classmethod async def execute(cls, model_task_id) -> IO.NodeOutput: response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoMeshSegmentationRequest(original_model_task_id=model_task_id), ) task_id, model = await poll_until_finished(cls, response, average_duration=160) return IO.NodeOutput(f"{task_id}.glb", task_id, model, ",".join(part_names_from_glb(model))) class TripoMeshCompleteNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoMeshCompleteNode", display_name="Tripo: Complete Mesh Parts", category="partner/3d/Tripo", description="Completes the parts of a segmented model and repairs missing regions.", inputs=[ IO.Custom("SEGMENT_TASK_ID").Input("segment_task_id"), IO.String.Input( "part_names", default="", optional=True, tooltip="Comma-separated part names to complete. Empty completes every part.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB"), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( expr="""{"type":"usd","usd":0.5, "format": {"approximate": true}}""", ), ) @classmethod async def execute(cls, segment_task_id, part_names: str = "") -> IO.NodeOutput: response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoMeshCompletionRequest( original_model_task_id=segment_task_id, part_names=split_part_names(part_names), ), ) return glb_output(*await poll_until_finished(cls, response, average_duration=240)) class TripoRetopologyNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoRetopologyNode", display_name="Tripo: Retopology", category="partner/3d/Tripo", description="Rebuilds a low-poly mesh with clean topology from a high-poly model.", inputs=[ IO.Custom("MODEL_TASK_ID,SEGMENT_TASK_ID").Input("model_task_id"), IO.Int.Input( "face_limit", default=-1, min=-1, max=20000, tooltip="Target face count: 500-20,000 triangles or 500-10,000 quads. -1 lets Tripo choose.", ), IO.Boolean.Input( "quad", default=False, tooltip="Quad mesh output. Tripo delivers quad meshes as FBX, so the result " "arrives on the FBX output and the GLB output stays empty.", ), IO.Boolean.Input( "bake", default=True, optional=True, advanced=True, tooltip="Bake the source textures onto the low-poly mesh.", ), IO.String.Input( "part_names", default="", optional=True, advanced=True, tooltip="Comma-separated part names from Tripo: Segment Model. Empty processes the whole model.", ), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB", tooltip="Empty when quad is enabled."), IO.File3DFBX.Output(display_name="FBX", tooltip="Only populated when quad is enabled."), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( expr="""{"type":"usd","usd":0.3, "format": {"approximate": true}}""", ), ) @classmethod async def execute( cls, model_task_id, face_limit: int = -1, quad: bool = False, bake: bool = True, part_names: str = "", ) -> IO.NodeOutput: if face_limit != -1 and not 500 <= face_limit <= (10000 if quad else 20000): raise ValueError("face_limit must be between 500 and 20,000 for triangles or 500 and 10,000 for quads.") response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoHighpolyToLowpolyRequest( original_model_task_id=model_task_id, face_limit=face_limit if face_limit != -1 else None, quad=quad, bake=bake, part_names=split_part_names(part_names), ), ) return glb_or_fbx_output(*await poll_until_finished(cls, response, average_duration=200)) class TripoConversionNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoConversionNode", display_name="Tripo: Convert model", category="partner/3d/Tripo", inputs=[ IO.Custom("MODEL_TASK_ID,RIG_TASK_ID,RETARGET_TASK_ID,SEGMENT_TASK_ID").Input("original_model_task_id"), IO.Combo.Input("format", options=["GLTF", "USDZ", "FBX", "OBJ", "STL", "3MF"]), IO.Boolean.Input("quad", default=False, optional=True, advanced=True), IO.Int.Input( "face_limit", default=-1, min=-1, max=2000000, optional=True, advanced=True, ), IO.Int.Input( "texture_size", default=4096, min=128, max=8192, optional=True, advanced=True, ), IO.Combo.Input( "texture_format", options=["BMP", "DPX", "HDR", "JPEG", "OPEN_EXR", "PNG", "TARGA", "TIFF", "WEBP"], default="JPEG", optional=True, advanced=True, ), IO.Boolean.Input("force_symmetry", default=False, optional=True, advanced=True), IO.Boolean.Input("flatten_bottom", default=False, optional=True, advanced=True), IO.Float.Input( "flatten_bottom_threshold", default=0.01, min=0.01, max=1.0, optional=True, advanced=True, tooltip="Flattening depth used with flatten_bottom.", ), IO.Boolean.Input("pivot_to_center_bottom", default=False, optional=True, advanced=True), IO.Float.Input( "scale_factor", default=1.0, min=0.01, optional=True, advanced=True, ), IO.Boolean.Input( "with_animation", default=True, optional=True, advanced=True, tooltip="Keep the skeleton and animation of rigged or retargeted models.", ), IO.Boolean.Input("pack_uv", default=False, optional=True, advanced=True), IO.Boolean.Input( "bake", default=True, optional=True, advanced=True, tooltip="Bake advanced materials into the base textures for broader compatibility.", ), IO.String.Input("part_names", default="", optional=True, advanced=True), # comma-separated list IO.Combo.Input( "fbx_preset", options=["blender", "mixamo", "3dsmax", "bake_scale"], default="blender", optional=True, advanced=True, tooltip="FBX compatibility preset. bake_scale bakes the scale transform into the geometry.", ), IO.Boolean.Input("export_vertex_colors", default=False, optional=True, advanced=True), IO.Combo.Input( "export_orientation", options=["default", "+x", "-x", "+y", "-y"], default="default", optional=True, advanced=True, tooltip="Forward axis of the exported model. default keeps Tripo's +x.", ), IO.Boolean.Input("animate_in_place", default=False, optional=True, advanced=True), ], outputs=[ IO.File3DAny.Output( display_name="model_3d", tooltip="Converted model in the requested format. OBJ is delivered by Tripo as a ZIP archive " "(mesh, material and textures).", ), ], hidden=[ IO.Hidden.auth_token_comfy_org, IO.Hidden.api_key_comfy_org, IO.Hidden.unique_id, ], is_api_node=True, is_output_node=True, price_badge=IO.PriceBadge( depends_on=IO.PriceBadgeDepends( widgets=[ "quad", "face_limit", "texture_size", "texture_format", "flatten_bottom", "pivot_to_center_bottom", "scale_factor", ], ), expr=""" ( $face := (widgets.face_limit != null) ? widgets.face_limit : -1; $texSize := (widgets.texture_size != null) ? widgets.texture_size : 4096; $scale := (widgets.scale_factor != null) ? widgets.scale_factor : 1; $texFmt := (widgets.texture_format != "" ? widgets.texture_format : "jpeg"); $advanced := widgets.quad or widgets.flatten_bottom or widgets.pivot_to_center_bottom or ($face != -1) or ($texSize != 4096) or ($scale != 1) or ($texFmt != "jpeg"); {"type":"usd","usd": ($advanced ? 0.1 : 0.05), "format": {"approximate": true}} ) """, ), ) @classmethod async def execute( cls, original_model_task_id, format: str, quad: bool, force_symmetry: bool, face_limit: int, flatten_bottom: bool, flatten_bottom_threshold: float, texture_size: int, texture_format: str, pivot_to_center_bottom: bool, scale_factor: float, with_animation: bool, pack_uv: bool, bake: bool, part_names: str, fbx_preset: str, export_vertex_colors: bool, export_orientation: str, animate_in_place: bool, ) -> IO.NodeOutput: if not original_model_task_id: raise RuntimeError("original_model_task_id is required") # Parse part_names from comma-separated string to list part_names_list = split_part_names(part_names) response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=TripoConvertModelRequest( original_model_task_id=original_model_task_id, format=format, quad=quad if quad else None, force_symmetry=force_symmetry if force_symmetry else None, face_limit=face_limit if face_limit != -1 else None, flatten_bottom=flatten_bottom if flatten_bottom else None, flatten_bottom_threshold=flatten_bottom_threshold if flatten_bottom else None, texture_size=texture_size if texture_size != 4096 else None, texture_format=texture_format if texture_format != "JPEG" else None, pivot_to_center_bottom=pivot_to_center_bottom if pivot_to_center_bottom else None, scale_factor=scale_factor if scale_factor != 1.0 else None, with_animation=with_animation, pack_uv=pack_uv if pack_uv else None, bake=bake, part_names=part_names_list, fbx_preset=fbx_preset if fbx_preset != "blender" else None, export_vertex_colors=export_vertex_colors if export_vertex_colors else None, export_orientation=export_orientation if export_orientation != "default" else None, animate_in_place=animate_in_place if animate_in_place else None, ), ) _, model = await poll_until_finished(cls, response, average_duration=30) return IO.NodeOutput(model) class TripoImportModelNode(IO.ComfyNode): """Imports an external 3D model into Tripo, producing a MODEL_TASK_ID for post-processing nodes.""" SUPPORTED_FORMATS = ("glb", "fbx", "obj", "stl") @classmethod def define_schema(cls): return IO.Schema( node_id="TripoImportModelNode", display_name="Tripo: Import Model", category="partner/3d/Tripo", description="Import an external 3D model (e.g. from Rodin, Hunyuan3D or a local file) into Tripo " "to use it with Tripo's post-processing nodes: Texture, Rig, Convert. " "GLB is recommended: textures survive import only when embedded in the file. " "Note that texturing an imported model requires a texture prompt.", inputs=[ IO.MultiType.Input( "model_3d", types=[IO.File3DGLB, IO.File3DFBX, IO.File3DOBJ, IO.File3DSTL, IO.File3DAny], tooltip="3D model to import (GLB / FBX / OBJ / STL, up to 150 MB). " "OBJ and STL files carry no embedded textures.", ), ], outputs=[ IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), ], 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( expr="""{"type":"text","text":"Free"}""", ), ) @classmethod async def execute(cls, model_3d: Types.File3D) -> IO.NodeOutput: file_format = (model_3d.format or "").lstrip(".").lower() if file_format == "gltf": raise ValueError( "GLTF (.gltf) references external files and cannot be imported. Export a single-file GLB instead." ) if file_format not in cls.SUPPORTED_FORMATS: raise ValueError( f"Unsupported 3D format '{file_format or 'unknown'}'. " f"Tripo import supports: {', '.join(f.upper() for f in cls.SUPPORTED_FORMATS)}." ) size = len(model_3d.get_bytes()) if size > 150 * 1024 * 1024: raise ValueError(f"Model file is {size / (1024 * 1024):.1f} MB; Tripo import allows up to 150 MB.") url = await upload_3d_model_to_comfyapi(cls, model_3d, file_format) response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/import", method="POST"), response_model=TripoTaskResponse, data=TripoImportModelRequest(url=url, format=file_format), ) if response.code != 0: raise RuntimeError(f"Failed to import model: {response.error}") task_id = response.data.task_id response_poll = await poll_op( cls, poll_endpoint=ApiEndpoint(path=f"/proxy/tripo/v2/openapi/task/{task_id}"), response_model=TripoTaskResponse, failed_statuses=[ TripoTaskStatus.FAILED, TripoTaskStatus.CANCELLED, TripoTaskStatus.UNKNOWN, TripoTaskStatus.BANNED, TripoTaskStatus.EXPIRED, ], status_extractor=lambda x: x.data.status, progress_extractor=lambda x: x.data.progress, estimated_duration=10, ) if response_poll.data.status != TripoTaskStatus.SUCCESS: raise RuntimeError(f"Failed to import model: {response_poll}") return IO.NodeOutput(task_id) def _p1_price_expr(*, geometry_credits: int, textured_credits: int, detailed_credits: int, extreme_credits: int) -> str: return ( "(" " $mode := widgets.output_mode;" ' $tq := $lookup(widgets, "output_mode.texture_quality");' f' $textured := $tq = "extreme" ? {extreme_credits} : ($tq = "detailed" ? {detailed_credits} : {textured_credits});' f' $credits := $mode = "geometry only" ? {geometry_credits} : $textured;' ' {"type":"usd","usd": $credits * 0.01, "format": {"approximate": true}}' ")" ) def _p1_textured_inputs(*, include_image_alignment: bool) -> list: """Inputs shown inside the 'Textured' branch of the P1 output_mode DynamicCombo.""" inputs: list = [ IO.Boolean.Input("pbr", default=True, tooltip="Include PBR maps. When on, base texture is forced on too."), IO.Combo.Input( "texture_quality", options=["standard", "detailed", "extreme"], default="standard", tooltip="detailed = HD textures, extreme = 8K Ultra textures.", ), ] if include_image_alignment: inputs.extend( [ IO.Combo.Input( "texture_alignment", options=["original_image", "geometry"], default="original_image", tooltip="Prioritize visual fidelity to the source image, or alignment to the mesh geometry.", ), IO.Combo.Input( "orientation", options=["default", "align_image"], default="default", tooltip="Rotate the output to match the source image. Only applies when textured.", ), ] ) inputs.append(IO.Int.Input("texture_seed", default=42, min=0, max=SEED_MAX, advanced=True)) return inputs def _build_p1_output_mode(*, include_image_alignment: bool) -> IO.DynamicCombo.Input: return IO.DynamicCombo.Input( "output_mode", options=[ IO.DynamicCombo.Option("Geometry only", []), IO.DynamicCombo.Option("Textured", _p1_textured_inputs(include_image_alignment=include_image_alignment)), ], tooltip='"Geometry only" returns an untextured mesh. "Textured" adds color/PBR maps.', ) def _resolve_p1_texture_fields(output_mode: dict) -> dict: """Translate the output_mode DynamicCombo payload into P1 request fields. pbr=true forces texture=true server-side, but we send both explicitly so the intent is visible in the request body and logs. """ mode = output_mode["output_mode"] if mode == "Geometry only": return {"texture": False, "pbr": False} out = { "texture": True, "pbr": bool(output_mode.get("pbr", True)), "texture_quality": output_mode.get("texture_quality", "standard"), "texture_seed": output_mode.get("texture_seed"), } if "texture_alignment" in output_mode: out["texture_alignment"] = output_mode["texture_alignment"] if "orientation" in output_mode: out["orientation"] = output_mode["orientation"] return out def _p1_common_inputs() -> list: """Inputs shared by all P1 nodes (placed after output_mode).""" return [ IO.Int.Input( "face_limit", default=-1, min=-1, max=20000, optional=True, advanced=True, tooltip="Target face count, 48-20000. -1 lets Tripo pick adaptively.", ), IO.Int.Input("model_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), IO.Boolean.Input( "auto_size", default=False, optional=True, advanced=True, tooltip="Scale the output to approximate real-world meters.", ), IO.Boolean.Input( "export_uv", default=True, optional=True, advanced=True, tooltip="UV unwrap during generation. Turn off for faster geometry-only runs.", ), IO.Boolean.Input( "compress_geometry", default=False, optional=True, advanced=True, tooltip="Apply meshopt geometry compression (EXT_meshopt_compression). Smaller files, " "but ComfyUI's 3D preview cannot display them; decompress before editing.", ), ] def _build_p1_request_kwargs( *, output_mode: dict, face_limit: int, model_seed: int, auto_size: bool, export_uv: bool, compress_geometry: bool, ) -> dict: """Common P1 request fields shared by all three node types.""" kwargs: dict = { "model_seed": model_seed, "face_limit": face_limit if face_limit != -1 else None, "auto_size": auto_size, "export_uv": export_uv, "compress": "geometry" if compress_geometry else None, } kwargs.update(_resolve_p1_texture_fields(output_mode)) return kwargs class TripoP1TextToModelNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoP1TextToModelNode", display_name="Tripo P1: Text to Model", category="partner/3d/Tripo", description="Tripo P1 text-to-3D. Optimized for low-poly, game-ready meshes with stable topology.", inputs=[ IO.String.Input("prompt", multiline=True, tooltip="Up to 1024 characters."), IO.String.Input("negative_prompt", multiline=True, optional=True, tooltip="Up to 255 characters."), _build_p1_output_mode(include_image_alignment=False), IO.Int.Input("image_seed", default=42, min=0, max=SEED_MAX, optional=True, advanced=True), *_p1_common_inputs(), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB"), ], 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=["output_mode", "output_mode.texture_quality"]), expr=_p1_price_expr(geometry_credits=30, textured_credits=40, detailed_credits=50, extreme_credits=60), ), ) @classmethod async def execute( cls, prompt: str, output_mode: dict, negative_prompt: str | None = None, image_seed: int | None = None, face_limit: int = -1, model_seed: int | None = None, auto_size: bool = False, export_uv: bool = True, compress_geometry: bool = False, ) -> IO.NodeOutput: if not prompt.strip(): raise RuntimeError("Prompt is required") common = _build_p1_request_kwargs( output_mode=output_mode, face_limit=face_limit, model_seed=model_seed, auto_size=auto_size, export_uv=export_uv, compress_geometry=compress_geometry, ) request = TripoP1TextToModelRequest( prompt=prompt, negative_prompt=negative_prompt or None, image_seed=image_seed, **common, ) response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=request, ) return glb_output(*await poll_until_finished(cls, response, average_duration=60)) class TripoP1ImageToModelNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoP1ImageToModelNode", display_name="Tripo P1: Image to Model", category="partner/3d/Tripo", description="Tripo P1 image-to-3D. Optimized for low-poly, game-ready meshes.", inputs=[ IO.Image.Input("image"), _build_p1_output_mode(include_image_alignment=True), IO.Boolean.Input( "enable_image_autofix", default=False, optional=True, advanced=True, tooltip="Pre-process the input image for better generation quality.", ), *_p1_common_inputs(), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB"), ], 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=["output_mode", "output_mode.texture_quality"]), expr=_p1_price_expr(geometry_credits=40, textured_credits=50, detailed_credits=60, extreme_credits=70), ), ) @classmethod async def execute( cls, image: Input.Image, output_mode: dict, enable_image_autofix: bool = False, face_limit: int = -1, model_seed: int | None = None, auto_size: bool = False, export_uv: bool = True, compress_geometry: bool = False, ) -> IO.NodeOutput: if image is None: raise RuntimeError("Image is required") tripo_file = TripoFileReference( root=TripoUrlReference( url=(await upload_images_to_comfyapi(cls, image, max_images=1))[0], type="jpeg", ) ) common = _build_p1_request_kwargs( output_mode=output_mode, face_limit=face_limit, model_seed=model_seed, auto_size=auto_size, export_uv=export_uv, compress_geometry=compress_geometry, ) request = TripoP1ImageToModelRequest( file=tripo_file, enable_image_autofix=enable_image_autofix, **common, ) response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=request, ) return glb_output(*await poll_until_finished(cls, response, average_duration=60)) class TripoP1MultiviewToModelNode(IO.ComfyNode): @classmethod def define_schema(cls): return IO.Schema( node_id="TripoP1MultiviewToModelNode", display_name="Tripo P1: Multiview to Model", category="partner/3d/Tripo", description="Tripo P1 multiview-to-3D from 2-4 reference images in [front, left, back, right] order. " "Front is required; any combination of the other three may be omitted.", inputs=[ IO.Image.Input("image", tooltip="Front view (0°). Required."), IO.Image.Input( "image_left", optional=True, tooltip="Left view (90°), i.e. the subject's left side.", ), IO.Image.Input("image_back", optional=True, tooltip="Back view (180°)."), IO.Image.Input( "image_right", optional=True, tooltip="Right view (270°), i.e. the subject's right side.", ), _build_p1_output_mode(include_image_alignment=True), *_p1_common_inputs(), ], outputs=[ IO.String.Output(display_name="model_file"), # for backward compatibility only IO.Custom("MODEL_TASK_ID").Output(display_name="model task_id"), IO.File3DGLB.Output(display_name="GLB"), ], 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=["output_mode", "output_mode.texture_quality"]), expr=_p1_price_expr(geometry_credits=40, textured_credits=50, detailed_credits=60, extreme_credits=70), ), ) @classmethod async def execute( cls, image: Input.Image, output_mode: dict, image_left: Input.Image | None = None, image_back: Input.Image | None = None, image_right: Input.Image | None = None, face_limit: int = -1, model_seed: int | None = None, auto_size: bool = False, export_uv: bool = True, compress_geometry: bool = False, ) -> IO.NodeOutput: views = [image, image_left, image_back, image_right] if sum(1 for v in views if v is not None) < 2: raise RuntimeError("Tripo P1 multiview requires at least 2 images (front plus one of left/back/right).") files: list[TripoFileReference] = [] for view in views: if view is None: files.append(TripoFileReference(root=TripoFileEmptyReference())) continue url = (await upload_images_to_comfyapi(cls, view, max_images=1))[0] files.append(TripoFileReference(root=TripoUrlReference(url=url, type="jpeg"))) common = _build_p1_request_kwargs( output_mode=output_mode, face_limit=face_limit, model_seed=model_seed, auto_size=auto_size, export_uv=export_uv, compress_geometry=compress_geometry, ) request = TripoP1MultiviewToModelRequest(files=files, **common) response = await sync_op( cls, endpoint=ApiEndpoint(path="/proxy/tripo/v2/openapi/task", method="POST"), response_model=TripoTaskResponse, data=request, ) return glb_output(*await poll_until_finished(cls, response, average_duration=80)) class TripoExtension(ComfyExtension): @override async def get_node_list(self) -> list[type[IO.ComfyNode]]: return [ TripoTextToModelNode, TripoImageToModelNode, TripoMultiviewToModelNode, TripoP1TextToModelNode, TripoP1ImageToModelNode, TripoP1MultiviewToModelNode, TripoImportModelNode, TripoImageToMultiviewNode, TripoEditMultiviewNode, TripoTextureNode, TripoRigCheckNode, TripoRigNode, TripoRetargetNode, TripoSegmentNode, TripoMeshCompleteNode, TripoRetopologyNode, TripoConversionNode, ] async def comfy_entrypoint() -> TripoExtension: return TripoExtension()