🔷 Create 3D Mesh (RDAWG+Open3D)

Every 3D workflow starts with geometry, and most of them start with a file. RDAWG3DCreateMesh is the alternative for when your geometry isn't in a file at all - it builds a mesh straight from the vertex and face tensors you feed it. Think procedural generation, a custom Python node that outputs point arrays, or a math operation that produces a shape you want to actually render. That's what this node is for.

It's the "hands-on" sibling of the Load 3D Model node in the same pack: Load Model reads .obj/.stl/.ply, Create Mesh takes raw numbers and constructs the Open3D mesh in memory. If your workflow only ever touches files, you'll probably never use this one. If you're doing anything procedural, it's the only way in.

How it works

Give it a vertices tensor of shape [N, 3] (xyz coordinates) and a faces tensor of shape [M, 3] (integer indices into the vertex list, in counter-clockwise order for sane normals). It moves them to the chosen device, wraps them in an Open3D TriangleMesh, computes vertex normals, and returns a standard RDAWG MESH plus an info string with the counts.

You can also feed optional vertex_colors ([N, 3] or [N, 4], RGB or RGBA) and texture_uv ([N, 2]) tensors. They get stored on the mesh data and carried through the pipeline, though in the current code the color/UV attributes are mostly bookkeeping until you hit a render node - colors render, so that's the one worth actually supplying.

The inputs that matter

• vertices - required, [N, 3] float tensor.
• faces - required, [M, 3] integer tensor. Don't skip it; a vertex soup isn't a mesh.
• device - auto picks CUDA when available.
• vertex_colors, texture_uv - optional; wire them if your source has them.

Output: mesh (MESH) ready for every other node in the pack - transform it, analyze it, remesh it, render it. And info (STRING) so you can verify vertex/face counts.

A useful wiring pattern: pair it with a torch-op custom node that generates a point grid, feed the points as vertices and a triangulation as faces, and you've got procedural geometry flowing through the same pipeline as loaded models. That's the node's real niche - it's the bridge between "math in tensors" and "mesh you can render."

Install

Same as the rest of the pack - ComfyUI Manager, search "RDAWG 3D Pack (CUDA 12.8 + PyTorch 2.9.0)", or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/rdawgemfl/rdawg_3D_pack
cd rdawg_3D_pack
python install.py

It needs Open3D 0.19.0+ (hard requirement - the whole pack refuses to load without it) and a CUDA-enabled PyTorch if you want GPU tensors. Python 3.11 is the author's recommended setup. Watch the installer's torch pin: if your ComfyUI already runs, you may not want it forcing 2.9.0+cu128 over your current install.

Where people get burned

• Face indices out of range - a common one when you build faces programmatically. Open3D will throw; check your indexing before blaming the node.
• Forgetting to include faces - no triangles, no mesh, just a cloud of points you can't render or analyze properly.
• Winding order - reversed faces give you inside-out normals and a mesh that renders black or looks hollow in the 3D-to-Image node. Counter-clockwise when viewed from outside is the rule.