> For the complete documentation index, see [llms.txt](https://docs.atlas.design/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.atlas.design/atlas-ai-studio-overview/node-index/mesh-nodes.md). # Mesh Nodes Mesh Nodes operate on 3D geometry created within Atlas workflows. They handle **mesh generation**, **transformation**, **cleanup**, **optimization**, and **scene assembly**, ensuring that assets become production-ready and correctly scaled. ## When to use mesh nodes * **Generate 3D from 2D.** Use Image → 3D or Multi-View → 3D as the entry point for new 3D content from concept art or multi-view character sheets. See [3D Generation Best Practices](/atlas-ai-studio-overview/node-index/mesh-nodes/3d-generation-best-practices.md) for the deep dive on backends, pitfalls, and post-processing. * **Make AI-generated meshes game-ready.** Use Optimize Mesh, Reduce Polycount, and Auto Transform Mesh to bring dense AI-generated geometry into game-engine territory (polycount, topology, scale, pivot). * **Re-texture an existing asset.** Use Re-texture Mesh with a style reference image to restyle a model without regenerating geometry. Useful for variant generation. * **Bake high-poly detail onto low-poly.** Generate at high quality, retopologize, bake normal and PBR maps onto the low-poly mesh. The Bake High-Poly to Low-Poly workflow covers this end to end. * **Rig and animate generated characters.** Use Rig Humanoid Mesh + Animate Rigged Model for full character pipelines from concept art to game-ready animated NPCs. * **Assemble scenes from generated meshes.** Use Compose 3D Scene to arrange multiple generated meshes into a layout based on a text prompt. ### Image **→** 3D The **Image** **→ 3D** node converts a single reference image into a **3D mesh**. * Takes an **image input** and reconstructs a 3D model. * Multiple **backends** are available (low-poly, high-detail, quad-based, triangle-based, stylized, realistic). * Output quality varies based on backend. * Use this node whenever you want to turn a concept art, render, or isolated product image into a mesh. More details are provided in the **Image**->**3D** sub-section.

\### Fast Image \*\*→\*\* 3D Rapidly generates a 3D reconstruction from a single 2D image in approximately 30 seconds. * Prioritizes speed and rough volume, making it perfect for quick concept prototyping. * Features options for PBR (Physically Based Rendering) support to include lighting information in the output. * Backends: SAM3D or Hunyuan3D Rapid. * Ideal for: Creating background assets or quickly visualizing 2D concepts in 3D space.

\### Image \*\*→\*\* 3D (With Fallback) A production-oriented 3D generation node that attempts reconstruction using multiple AI backends sequentially. * If the primary backend fails, the node automatically retries with secondary "fallback" models to ensure a result is always produced. * Offers deep customization for quality, face limits, and PBR textures across up to 4 different backend attempts. * Inputs: Input Image, Multiple Backend choices, Retry Count. * Ideal for: Production pipelines where reliability and successful generation are critical. * Ideal for UGC use cases where reliability is critical

\### Multi-View \*\*→\*\* 3D Reconstructs a 3D mesh from a set of consistent images showing an object from different standardized angles. * Provides significantly higher geometric accuracy and consistency than single-image generation. * Accepts specific views (Front, Right, Left, Back, Top, Bottom) to build a comprehensive 3D volume. * Backends: Includes industry leaders like Tripo v3.0 and Meshy v6. * Ideal for: Creating high-fidelity 3D models from character sheets or multi-angle photographs.

### Re-texture Mesh The Re-t**exture Mesh** node regenerates or restyles the texture of an existing mesh. * Input: * A **reference style image** * An **existing mesh** * The resulting mesh receives a texture that matches the reference image. * Ideal for creating **style variations** or re-texturing an asset. Example: Change the style of the asset by using a new 2D concept as the texture reference.

\- Supports multiple style images as input (front, left, right, and back views) for improved retexturing accuracy and directional control.

\- Additional generation arguments are available with some backends for fine-tuning retexturing behavior. ### Extract Texture Maps Separates the visual components of a GLB mesh into individual PBR (Physically Based Rendering) texture files. * Extracts the Base Color, Roughness, Metallic, and Normal maps as individual 2D images. * Allows you to isolate and edit specific material properties (like making a surface shinier or adding bump detail) in 2D. * Outputs: Base Color Image, Roughness Image, Metallic Image, Normal Map Image.

### Apply Textures to Mesh Replaces or assigns 2D texture images to the specific material slots of a 3D model. * Takes a geometry-only or existing mesh and applies provided images to its UV-mapped surfaces. * Allows for selective replacement; only the maps you provide (e.g., just the Base Color or just the Normal Map) will be updated. * Inputs: Input Mesh, Base Color, Roughness, Metallic, Normal Map. * Ideal for: Re-assembling a model after editing its texture maps in 2D.

* Accepts a normal map convention setting and automatically converts DirectX maps to the glTF/OpenGL convention when needed. \### Auto Transform Mesh The **Auto Transform Mesh** node is one of the most essential post-processing tools. It automatically: * Applies **semantic world-scale correction** * Adjusts **dimensions** based on object type * Repositions the **origin** * Prepares the asset for proper placement in a game engine, CAD tool, or Atlas pipeline Use this node immediately after generating a model.

\### Mesh Multi-View Render Captures standardized 2D snapshots of a 3D model from multiple specified camera angles. * Uses yaw (horizontal) and pitch (vertical) coordinates to define exact rendering perspectives. * Essential for creating character sheets or preparing views for texture re-projection workflows. * Outputs: An array of images and the corresponding camera matrices used for the render. Note: This is a specialized tool typically used in advanced multi-view pipelines.

\### Create Occlusions Mask Generates UV-baked visibility maps that identify which surface areas are visible from specific camera views. * Detects areas of the mesh that are hidden or shadowed, preventing textures from "smearing" onto unseen geometry. * Crucial for high-quality texture projection where multiple 2D views must be blended seamlessly. * Inputs: Input Mesh, Camera Matrices (from the Multi-View Render node). * Outputs: An array of grayscale occlusion masks.

\### Project Multi-View Images to Mesh Transfers color data from a set of 2D images back onto the 3D surface of a mesh using UV coordinates. * Blends multiple perspectives together while using occlusion masks to ensure textures are only applied to visible surfaces. * Includes "Softmax Sharpening" to control the clarity and transition between different projected views. * Inputs: Mesh, Image Array, Camera Matrices, Occlusion Masks. Ideal for: Texturing a 3D model using AI-generated or edited 2D reference images.

\### Reduce Polycount Reduces the polygon count of a mesh. * Input: desired polycount value * Re-bakes textures automatically * Useful for optimizing **AI-generated high-density meshes** This is essential for performance-friendly assets. ### Optimize Mesh Reconstructs the mesh topology and produces a cleaner, more manageable geometry structure. Reduces or increases polygon count while maintaining the model’s overall shape. * Topology options: * **Triangle** for most general uses. * **Quad** for modeling workflows. * Input: target polygon count This node is ideal for preparing AI-generated meshes that come in overly dense or irregular form.

\- Some backends offer voxel-based remeshing with voxel size, narrow band width, and surface projection controls as an alternative to target polygon count and topology selection.

### Mesh BBox Fit Scales a mesh **non-uniformly** so that its **world-space bounding box** exactly matches specified X, Y, Z dimensions. * Input: target width, height, depth * Output: scaled mesh with exact real-world bounding box Useful for making an asset match required dimensions precisely.

\### Set Mesh Origin Sets the mesh origin based on bounding-box parameters. * Input: desired origin position (e.g., upper bound, bbox center) * Output: repositioned mesh origin used for clean pivoting and placement This is important for alignment, snapping, and scene assembly.

\### Text to Origin Uses a **text instruction** to modify a mesh's origin. Examples: * “Set origin to bottom center” * “Move pivot to the front face” * “Place origin at the geometric center” Helpful when precise manual origin adjustments are needed.

\### Rotate Mesh Towards Axis Rotates the mesh around **(0, 0, 0)** so that it faces a selected axis. * Supports presets such as: * Face −Y * Face +Y * Face −X / +X * Face −Z / +Z * Assumes the input mesh initially faces **−Y**. Ensures consistent orientation across generated assets.

\### Compose 3D Scene Takes your generated meshes and arranges them into a **simple 3D scene** based on a text prompt. * Input meshes + prompt * Output: arranged layout with placement, rotation, spacing * Useful for quick scene design or previews

\### Mask to Spline Converts a **binary mask** into a spline. * Requires input binary mask where your desired object is **white**. * Outputs a spline based on the **largest connected white region**. * Mask can be prepared via **Text+Image -> Image nodes** beforehand. Used for shape extraction, outline-based modeling, or path generation.

\### Seperate Object Parts Automatically segment a 3D mesh into individual parts based on geometric and semantic analysis. * Uses AI to identify and detach discrete components (e.g., separating a character's clothing or a machine's parts) into a segmented GLB. * The primary backend supports up to 30k faces, while a fallback handles denser meshes up to 1.5M faces. * Inputs: Input Mesh, Backend Selection, Seed. * Ideal for: Modifying or isolating specific pieces of a combined AI-generated model.

\### Rig Humanoid Mesh Automatically generates a skeletal structure and skin weights for humanoid character models. * Creates an armature that allows the character to be posed and animated. * Requires the model to be in a standard pose (T-pose or A-pose) and calibrated for height in meters for accurate skeletal placement. * Outputs: Rigged Mesh, plus preset "Walking" and "Running" previews for instant testing.

\### Animate Rigged Model Applies motion data and specific animations to a previously rigged character mesh. * Utilizes a massive library of preset actions ranging from daily movements to combat and dancing. * Requires metadata from a compatible rigging node to correctly map animations to the skeleton. * Inputs: Rigged Model Metadata, Animation Selection (e.g., Fighting, Dancing, WalkAndRun). * Ideal for: Quickly bringing static characters to life for games or cinematics.

\### Omnipart Segments an image and generates **separate mesh parts**. * Outputs: * Segmentation map * Individual GLBs for each part * Optional merged mesh * Ideal for breaking an asset into modules or components. Perfect for kitbashing, modular asset workflows, or creating parametric components from a single image.

\### Bake High-Poly to Low-Poly — Workflow Transfers texture detail from a high-polygon mesh onto an optimized low-polygon version, preserving visual fidelity while reducing geometry complexity. * Inputs: * **High-poly mesh** with detailed texture * **Low-poly mesh** (typically from Optimize Mesh) * Uses **Mesh BBox Fit** to align the scale and position of both meshes before baking. * The **Bake High-Poly to Low-Poly** node projects surface detail from the high-poly texture onto the low-poly UV layout. * Output: a low-poly mesh with baked texture that retains the appearance of the original high-resolution asset. * Typical workflow: generate or import dense mesh → optimize geometry → align bounding boxes → bake texture detail. Useful for creating game-ready assets from AI-generated or sculpted high-detail models, maintaining visual quality while meeting real-time performance budgets.

## Common pitfalls * **Skipping Auto Transform Mesh.** Generated meshes often have non-standard pivot, scale, and orientation. Without normalization they're hard to use in procedural assembly or engine integration. Always run Auto Transform Mesh after generation. * **Using high-detail backends for game targets.** High-detail backends produce dense meshes that need retopology and baking before they're game-ready. For real-time targets, start with low-poly or stylized backends and skip the bake step entirely. * **Optimizing before texturing.** Polycount reduction can damage UV layouts. Either texture first then optimize with re-baking, or use Bake High-Poly to Low-Poly which handles the order correctly. * **Generating from poor reference images.** 3D generation quality directly tracks input image quality. Process reference images through [2D Post Processing](/atlas-ai-studio-overview/node-index/image-nodes/2d-post-processing-nodes.md) (background removal, perspective adjustment, isolation) before feeding mesh nodes. * **Forgetting Image to 3D (With Fallback) for production UGC.** Single-backend generation can fail on unusual inputs. For player-facing UGC where reliability matters more than per-asset quality, use the Fallback variant which retries across backends automatically. ## Related nodes * [Input Nodes](/atlas-ai-studio-overview/node-index/input-nodes.md) — Input Image, Input Images (for multi-view), and Input Mesh feed mesh-node workflows. * [Image Nodes](/atlas-ai-studio-overview/node-index/image-nodes.md) — generate and refine 2D references before feeding mesh nodes. Image quality determines 3D quality. * [Utility Nodes](/atlas-ai-studio-overview/node-index/utility-nodes.md) — Split Character Sheet, Create Image List for multi-view inputs; LLM nodes for parametric workflow construction. * [API Nodes](/atlas-ai-studio-overview/node-index/api-nodes.md) — expose mesh workflows as callable APIs for Unity and Unreal integration. * [3D Generation Best Practices](/atlas-ai-studio-overview/node-index/mesh-nodes/3d-generation-best-practices.md) — deep dive on backend selection, input prep, and post-generation pipelines. * [Animation Nodes](/atlas-ai-studio-overview/node-index/mesh-nodes/animation-nodes.md) — character-specific rigging and animation workflows that build on the rigging nodes here. ## Frequently asked questions **Which mesh node should I start with?** For most use cases, start with Image → 3D and follow [3D Generation Best Practices](/atlas-ai-studio-overview/node-index/mesh-nodes/3d-generation-best-practices.md). For character sheets with multiple views, start with Multi-View → 3D. For production UGC where reliability is critical, use Image → 3D (With Fallback). **How do I make AI-generated meshes game-ready?** Standard chain: generate → Auto Transform Mesh → Optimize Mesh (for polycount reduction and topology cleanup) → texture or bake high-to-low → Apply Textures to Mesh. For characters, add Rig Humanoid Mesh + Animate Rigged Model at the end. **Can I get quad-based meshes for sculpting?** Yes. Select a quad-based backend in Image → 3D, or use Optimize Mesh with Quad topology setting. Quads are preferred for sculpting workflows in ZBrush, Blender, or Maya; triangles are standard for real-time engines. **What's the difference between Reduce Polycount and Optimize Mesh?** Reduce Polycount aggressively cuts polygon count and re-bakes textures automatically; use when you have a clear polycount target. Optimize Mesh reconstructs topology more carefully, supporting triangle or quad output and voxel-based remeshing options; use when topology quality matters more than hitting an exact polycount. **Can mesh nodes export FBX or USD?** The platform's native output is GLB. For other formats, use external conversion tools (Blender, FBX SDK) downstream of the workflow, or wire the API Output into your engine and convert on import. **How do I rig a non-humanoid character?** Rig Humanoid Mesh is purpose-built for humanoid topology. For non-humanoid rigs (creatures, vehicles, props), use external rigging tools after generation. Atlas's rigging stack is humanoid-focused; expect updates for other rig types in future releases. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.atlas.design/atlas-ai-studio-overview/node-index/mesh-nodes.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.