> 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/3d-generation-best-practices.md).

# 3D Generation Best Practices

Each game has unique constraints, but the patterns for generating production-quality 3D assets in Atlas are consistent. This page covers how to prepare inputs, choose the right backend model, route outputs into the rest of your pipeline, and avoid the most common mistakes when generating 3D meshes from a single image.

## When to use the Image to 3D node

Reach for Image to 3D when you have a reference image (concept art, photograph, or 2D render) and need a corresponding 3D mesh as the starting point for a production asset. Common use cases:

* **Concepting and prototyping.** Generate a rough 3D version of a 2D concept in under a minute to evaluate proportions, silhouette, and scale before committing modeling time.
* **Asset library expansion.** Convert existing 2D library art into 3D variants for use in game scenes, marketing material, or virtual production.
* **Hero asset starts.** Produce a high-detail mesh that a technical artist then refines, retopologizes, or bakes down to a game-ready low-poly target.
* **Stylized object generation.** Use stylization-aware backends to produce meshes that respect a specific art direction rather than defaulting to generic realism.

If you need a multi-view-conditioned mesh (front, back, and side reference), pair Image to 3D with the **Multi-view Generation** capability in the upstream image nodes for stronger geometric accuracy on occluded surfaces.

## Image **→** 3D Node

The **Image to 3D** node converts a single image into a fully generated **3D mesh**.\
This node is most effective when the input image is clean, isolated, and visually informative.

### Preparing the Input Image <a href="#id-1-preparing-the-input-image" id="id-1-preparing-the-input-image"></a>

For the best 3D results, the source image should:

* show **only the desired object**
* have a **neutral background** (white, gray, or solid color)
* include **depth cues** such as shadows
* preferably use a **perspective camera angle**
* avoid clutter, overlapping objects, or busy patterns

To achieve this, you can first process the original scene using:

* **Multimodal Node** → isolate the object with neutral background
* **Precise Text Edit Node** → remove all other elements cleanly

<figure><img src="/files/3GkEi2cbMRlewQyO2oOy" alt="" width="563"><figcaption></figcaption></figure>

These steps help the 3D model generator correctly infer:

* thickness
* volume
* proportions
* silhouette
* material hints

### Backends & Output Variation <a href="#id-2-backends--output-variation" id="id-2-backends--output-variation"></a>

The Image to 3D node includes **multiple backend models**, each producing different types of meshes:

#### Backend Differences <a href="#backend-differences" id="backend-differences"></a>

* **High-detail models** → strong surface accuracy
* **Low-detail models** → simplified forms for fast iteration
* **Low-poly models** → game-ready stylized assets
* **Quad-based meshes** → ideal for sculpting or retopology
* **Triangle-based meshes** → standard for real-time engines
* **PBR-enabled meshes** → includes color + material maps
* **Mesh-only output** → no textures, only geometry

<figure><img src="/files/P7BqL8l288eWjyNGj3YF" alt="" width="563"><figcaption></figcaption></figure>

<figure><img src="/files/B0EcNSBYBM5B0Z5gN7zm" alt="" width="563"><figcaption></figcaption></figure>

You can toggle:

* **Disable PBR**
* **Disable Texture** for geometry only output.

This helps adapt the output to different pipelines (Blender, Unreal, Unity, CAD, etc.).

<figure><img src="/files/U4z5VO7AteFPBn2qMe8B" alt="" width="563"><figcaption></figcaption></figure>

<figure><img src="/files/JSZR6Pd6zADvFqcKmxkF" alt="" width="563"><figcaption></figcaption></figure>

<figure><img src="/files/mjS96uRmXkO7phL8uUbD" alt="" width="563"><figcaption></figcaption></figure>

### Generating the Model <a href="#id-3-generating-the-model" id="id-3-generating-the-model"></a>

Once the image and settings are ready:

1. Connect your isolated image to the **Image Input** of the Image to 3D node
2. Select backend model
3. Click **Run**

The node returns:

* a **3D preview**
* a wireframe preview
* a downloadable **.glb** model

You can download it directly or refine it using the next stage of mesh nodes.

### After Generation: Next Steps <a href="#id-4-after-generation-next-steps" id="id-4-after-generation-next-steps"></a>

After generating the mesh, you can optionally pass it through:

#### **Auto Mesh Transform** <a href="#auto-mesh-transform" id="auto-mesh-transform"></a>

* fix origin point
* normalize scale
* reorient axes
* center the model
* prepare it for procedural assembly

#### **Texture Mesh** <a href="#texture-mesh" id="texture-mesh"></a>

* add or enhance textures
* refine materials

#### **Blender / Unreal / Unity via API Nodes** <a href="#blender--unreal--unity" id="blender--unreal--unity"></a>

* import for scene assembly
* integrate into procedural systems
* convert to kits or asset libraries

<figure><img src="/files/ddfpqZmDCkv83onzXmOg" alt="" width="563"><figcaption></figcaption></figure>

### Bake High-Poly to Low-Poly

Transfers detail from a high-polygon mesh to a low-polygon proxy by baking normal maps and PBR texture channels. The node outputs standard texture maps that can be applied to game-ready geometry for efficient real-time rendering.

<figure><img src="/files/Gz1wuqouh4kt48RXosud" alt="" width="563"><figcaption></figcaption></figure>

* **High-poly mesh input** — source geometry containing sculpted or subdivided detail
* **Low-poly mesh input** — target game mesh with simplified topology and UV layout
* **Texture resolution** — explicit pixel dimensions for baked maps; no longer auto-detected from source
* **Bake margin** — scales automatically with resolution to prevent seam artifacts at higher output sizes
* **Output channels** — normal, albedo, roughness, metallic, and ambient occlusion maps
* **UV requirement** — low-poly mesh must have non-overlapping UVs in the 0–1 space

Useful for generating optimized hero assets, LOD transitions, and production-ready character models from sculpted prototypes.

* **AO samples** — adjustable sampling count for ambient occlusion baking; higher values improve quality at the cost of longer bake time
* **Texture margin** — manual control over edge dilation; Auto mode scales margin with resolution

## Common pitfalls

Five mistakes that consistently cost generation quality:

1. **Busy or cluttered input images.** Multiple objects, complex backgrounds, or overlapping subjects confuse the generator. Isolate the subject first with the Multimodal Node or Precise Text Edit Node.
2. **Front-only flat views.** Images shot dead-on with no perspective give the model no depth cue. Use a slight three-quarter angle whenever possible. Cast a subtle shadow to anchor scale.
3. **Selecting the wrong backend for the use case.** High-detail backends produce dense meshes that aren't game-ready without retopology. Low-poly backends produce stylized geometry that won't hold up under hero close-ups. Match the backend to downstream pipeline expectations.
4. **Generating before fixing texture and material requirements upstream.** If the eventual asset needs PBR materials at a specific resolution, generate with PBR enabled and the right texture size on the first pass. Re-running afterwards loses determinism.
5. **Skipping Auto Mesh Transform.** Generated meshes often have non-standard pivot points, scale, and orientation. Without normalization, the asset is harder to use in procedural assembly or engine integration. Always pass through Auto Mesh Transform for production work.

## Related nodes

* [Input Nodes](/atlas-ai-studio-overview/node-index/input-nodes.md) — uploading reference images and art bibles into your workflow
* [Image Generation Nodes](/atlas-ai-studio-overview/node-index/image-nodes/image-generation-nodes.md) — generating concept images that feed Image to 3D
* [Image Edit Nodes](/atlas-ai-studio-overview/node-index/image-nodes/image-edit-nodes.md) — refining and isolating subjects before generation
* [2D Post Processing Nodes](/atlas-ai-studio-overview/node-index/image-nodes/2d-post-processing-nodes.md) — preparing clean inputs (background removal, masking, recoloring)
* [Mesh Nodes](/atlas-ai-studio-overview/node-index/mesh-nodes.md) — overview of all mesh-related capabilities
* [API Nodes](/atlas-ai-studio-overview/node-index/api-nodes.md) — exporting your finished workflow as a callable API for Unreal, Unity, or Blender

## Frequently asked questions

**What input image resolution works best?**

A square or near-square image at 1024×1024 pixels or higher is ideal. Lower resolutions degrade detail recovery in the generated mesh; higher resolutions don't usually improve output and slow down inference.

**Can Image to 3D handle transparent backgrounds?**

Yes. Transparent PNG inputs work as expected. The generator treats transparent regions as empty space, which produces cleaner silhouettes than colored backgrounds. If your input has a complex background, isolate the subject first with the Multimodal Node.

**Which backend is best for game-ready output?**

For real-time engine targets (Unity, Unreal), start with the low-poly or stylized backends. They produce game-ready geometry directly. For hero assets where polycount matters less, the high-detail backends give better surface accuracy. Use Bake High-Poly to Low-Poly to combine both: generate high-detail first, retopologize to a low-poly target, then bake normal and PBR maps onto the low-poly mesh.

**Why does the back of my generated mesh look incorrect?**

Single-image input gives the model only one view, so the back, top, and occluded surfaces are inferred rather than observed. For better back-of-asset accuracy, use multi-view conditioning: provide front and back reference images, or enable Multiple-Angles LoRA preprocessing upstream.

**Can I generate quad-based meshes for sculpting?**

Yes. Select a quad-based backend in the Image to 3D node. Quad meshes are better suited for sculpting in ZBrush, Blender, or Maya. For real-time rendering, triangle-based meshes are typically more efficient.

**How do I use the generated mesh in Unreal or Unity?**

The output is a standard `.glb` file. Either download it directly and import via the engine's native asset pipeline, or wire your workflow into an [API Node](/atlas-ai-studio-overview/node-index/api-nodes.md) and have Unreal or Unity request the mesh on demand. The API approach is recommended for production pipelines because it keeps the workflow versioned and deterministic.


---

# 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/3d-generation-best-practices.md?ask=<question>&goal=<endgoal>
```

`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.