Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > ComfyUI_Antonioilev > 🧱 GPU Mesh Builder (Watertight)

ComfyUI Node: 🧱 GPU Mesh Builder (Watertight)

Class Name

AntonioilevRemeshGPU

Category
Antonioilev/Mesh
Author
antonioilev (Account age: 0days)
Extension
ComfyUI_Antonioilev
Latest Updated
2026-10-09
Github Stars
0.0K

How to Install ComfyUI_Antonioilev

Install this extension via the ComfyUI Manager by searching for ComfyUI_Antonioilev
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter ComfyUI_Antonioilev in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

🧱 GPU Mesh Builder (Watertight) Description

Rebuilds triangle meshes using GPU narrow-band remeshing with optional hole repair and sealing.

🧱 GPU Mesh Builder (Watertight):

AntonioilevRemeshGPU rebuilds a 3D mesh using GPU-accelerated narrow-band remeshing. It turns an existing surface into a new triangle mesh, which can help you create a more continuous surface when the original geometry has uneven or problematic faces. The process prepares the mesh, reconstructs its surface on a grid, and cleans the resulting geometry. It can also attempt additional sealing to make the result watertight, meaning the surface has no open edges. This is useful when you need a closed shell for later modeling or fabrication work, but watertightness is checked and reported rather than guaranteed. Remeshing may change fine details, face count, or separate parts of the original mesh.

🧱 GPU Mesh Builder (Watertight) Input Parameters:

trimesh

Required TRIMESH input containing the 3D mesh you want to rebuild. The node copies this mesh before processing it. Supply a mesh with vertices and faces; an empty or invalid mesh cannot provide the geometry needed for remeshing. This input has no numeric minimum, maximum, or default.

grid_resolution

Required INT controlling the resolution of the grid used to reconstruct the surface. A higher value gives the process more grid detail to work with, but generally requires more GPU memory and processing time; it does not guarantee that every original detail will survive. A lower value is useful for quicker tests or limited GPU memory. Default: 512; minimum: 64; maximum: 2048; step: 64.

band_width

Required FLOAT passed to the narrow-band remeshing operation as its band setting. The band defines how much space around the surface the reconstruction considers; the node also uses it to expand the processing domain. A wider band can increase the region processed, while a narrower band keeps it more confined. Its precise effect on a particular mesh depends on the remeshing operation. Default: 3.0; minimum: 1.0; maximum: 16.0; step: 0.5.

project_back

Required FLOAT passed to the remeshing operation to control projection back toward the source surface. Use it when comparing how closely the rebuilt result follows the original shape; changing it may alter the balance between the reconstructed surface and the source geometry. The supplied implementation does not establish a universal best value or guarantee that a higher setting always preserves more detail. Default: 0.15; minimum: 0.0; maximum: 1.0; step: 0.05.

repair_holes

Required BOOLEAN controlling an initial CPU-side repair pass. When true, the node attempts to fill holes, remove non-finite geometry values, and discard duplicate or degenerate faces before GPU processing. These operations may improve a damaged input, but they cannot repair every opening. When false, this initial pass is skipped; the GPU preparation still attempts its own hole-filling step. Default: true; options: true or false.

force_watertight

Required BOOLEAN controlling an additional sealing pass after remeshing. When true, the node cleans the result, retains its largest connected component if there are several, tries to fill holes, and attempts further repair if pymeshfix is available. This can remove smaller disconnected pieces, so inspect the result if those pieces matter to your artwork. The setting requests a repair attempt, not a guaranteed watertight result. When false, the additional sealing pass is skipped. Default: true; options: true or false.

pre_simplify_limit

Optional INT setting a face-count threshold for the input mesh before GPU processing. If the mesh exceeds this value, the node attempts to reduce it to the specified number of faces, first with Trimesh and then with an Open3D fallback. This can make a very dense mesh more manageable, but simplification may remove detail, and both methods can fail. Setting it to 0 disables the pre-simplification attempt. Default: 2000000; minimum: 0; maximum: 20000000; step: 100000.

max_hole_edges

Optional INT passed to the pymeshfix small-boundary filling attempt during final sealing. It sets the nbe value used by that repair operation, so adjust it only when you are evaluating how the optional sealing stage handles openings in your result. It has no effect when force_watertight is false or when the pymeshfix stage is skipped. Default: 500; minimum: 0; maximum: 20000; step: 50.

🧱 GPU Mesh Builder (Watertight) Output Parameters:

mesh

The resulting TRIMESH geometry. On a successful run, this is the rebuilt and cleaned mesh, including any final sealing attempt you enabled. Check its shape and separate parts before using it downstream, especially if the source contained multiple components. If remeshing fails inside the processing function, the node returns the original input mesh in this output instead; the presence of a mesh alone therefore does not confirm success.

info

A STRING describing the result or a processing failure. After a successful run, it reports the grid resolution, band and projection settings, input and output face counts, whether the result is watertight, and the number of connected components. When final sealing runs, it can also include notes about repair steps or skipped steps. If processing fails inside the remeshing function, the string begins with ERROR: and includes the exception message. Read this output alongside the mesh to distinguish a completed remesh from a fallback to the original geometry.

🧱 GPU Mesh Builder (Watertight) Usage Tips:

  • Start with the defaults, then inspect both the rebuilt shape and info. In particular, check watertight= before treating the result as a closed shell.
  • For a quick first pass or when GPU memory is limited, try grid_resolution=256. Increase it in steps if the result needs more geometric detail, checking processing time and memory use as you go.
  • For a very dense source mesh, keep pre_simplify_limit enabled and choose a threshold that preserves the details important to your image or model. Compare the result with the original, because pre-simplification changes the geometry before remeshing.
  • If the source has openings, leave repair_holes=true for the initial cleanup and force_watertight=true for the later sealing attempt. Inspect the output for missing small parts: final sealing keeps only the largest connected component when multiple components remain.
  • Change band_width and project_back one at a time while comparing results. This makes it easier to tell which setting affected the reconstructed surface.
  • Keep max_hole_edges at its default unless you are specifically testing the optional final hole-repair stage. Raising it cannot guarantee a watertight mesh.

🧱 GPU Mesh Builder (Watertight) Common Errors and Solutions:

ERROR: followed by a CUDA or out-of-memory message

  • Explanation: The node creates GPU tensors on cuda and performs GPU remeshing. The device may be unavailable, or the mesh and chosen settings may exceed available GPU memory.
  • Solution: Confirm that a compatible CUDA setup is available. Try a lower grid_resolution and a practical pre_simplify_limit; close other GPU-heavy applications before retrying.

ERROR: followed by an empty-mesh or reduction error

  • Explanation: The process needs vertices and faces to calculate the mesh bounds and build its GPU representation. An empty mesh, or one left without usable geometry, can cause this stage to fail.
  • Solution: Check the upstream mesh and supply valid geometry with faces. If the mesh was heavily simplified before this node, inspect that earlier result as well.

ERROR: followed by a mesh, CUDA, or remeshing exception

  • Explanation: An exception occurred during processing, and the node returned the original input mesh instead of a rebuilt result. The text after ERROR: is the specific exception reported by the failing operation.
  • Solution: Use that exception text to identify the failing stage. Check that the source mesh contains usable geometry and that the required GPU remeshing environment is available; then retry with a lower resolution or a simpler input mesh.

ModuleNotFoundError: No module named 'cumesh'

  • Explanation: The implementation imports cumesh before its processing error handler. If that package is unavailable, the node cannot start remeshing, and this exception may not be converted into an ERROR: info string.
  • Solution: Check the installation requirements for the node and install its compatible cumesh dependency in the environment running the node.

watertight=False

  • Explanation: This is a reported result, not an exception. The rebuilt mesh still has an opening or another condition that prevents it from being classified as watertight, even if sealing was enabled.
  • Solution: Inspect the source and result for open edges or difficult geometry. Retry with repair_holes and force_watertight enabled, and review any sealing notes in info. Do not assume the mesh is closed until the reported check says watertight=True.

pymeshfix skip: followed by an exception

  • Explanation: The optional pymeshfix stage of final sealing could not run. The node records the reason in info and continues with its other cleanup steps.
  • Solution: Read the exception text. If it indicates a missing package, install a compatible pymeshfix dependency; otherwise inspect the geometry supplied to the sealing stage. Check watertight= to determine whether the result is usable without that stage.

Simplify skipped: followed by an exception

  • Explanation: The input exceeded pre_simplify_limit, but both the initial simplification attempt and its Open3D fallback failed. The node continues with the unsimplified mesh, which may demand more GPU memory.
  • Solution: Reduce the source mesh upstream or check the available simplification dependencies. Lowering grid_resolution may also help the later GPU stage, but it does not fix the failed pre-simplification itself.

components= greater than 1

  • Explanation: The reported result contains multiple disconnected pieces. This is a status value, not an error, and may be intentional for a model made of separate objects.
  • Solution: Inspect whether the pieces belong in the artwork. If you need a single shell, examine the source geometry and the result; enabling force_watertight may retain only the largest component and discard smaller pieces.

🧱 GPU Mesh Builder (Watertight) Related Nodes

Go back to the extension to check out more related nodes.
ComfyUI_Antonioilev
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

🧱 GPU Mesh Builder (Watertight)