> 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 Transform Mesh** <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>

## Common pitfalls

1. **Busy or cluttered input images.** Multiple objects, complex backgrounds, or overlapping subjects prevent the Image to 3D node from inferring thickness, volume, proportions, and silhouette, producing distorted geometry. Isolate the subject first with the Multimodal Node for a neutral background, or remove other elements with the Precise Text Edit Node.
2. **Flat, dead-on source views.** An image with no perspective and no shadows gives the generator no depth cue, so scale and volume are guessed. Prefer a perspective camera angle and include shadows.
3. **Choosing a backend that mismatches the target pipeline.** High-detail backends produce dense meshes that are not game-ready without retopology; low-poly backends produce stylized geometry that will not hold up under hero close-ups. Selecting the wrong one forces a re-run to get usable topology.
4. **Toggling Disable PBR or Disable Texture after deciding you need maps.** If the asset requires color and material maps, generate with PBR enabled on the first pass; discovering the need afterward means re-running the generation.
5. **Feeding a raw generated mesh into procedural assembly.** Generated meshes often have non-standard pivot, scale, and orientation, causing misplacement in scenes. Pass them through Auto Transform Mesh first.
6. **Baking onto a low-poly mesh with overlapping UVs.** Bake High-Poly to Low-Poly requires non-overlapping UVs in the 0–1 space; overlapping UVs corrupt the baked normal and PBR channels.

## 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 art images that feed the Image to 3D node
* [Image Edit Nodes](/atlas-ai-studio-overview/node-index/image-nodes/image-edit-nodes.md) — refining and isolating subjects before 3D generation
* [2D Post Processing Nodes](/atlas-ai-studio-overview/node-index/image-nodes/2d-post-processing-nodes.md) — preparing clean inputs through background removal, masking, and recoloring
* [Mesh Nodes](/atlas-ai-studio-overview/node-index/mesh-nodes.md) — overview of all mesh-related capabilities, including Texture Mesh and Bake High-Poly to Low-Poly
* [API Nodes](/atlas-ai-studio-overview/node-index/api-nodes.md) — exporting a finished workflow as a callable API for scene assembly in Blender, Unreal, or Unity

## 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 do not usually improve output and slow down inference. The source image should show only the desired object on a neutral background such as white, gray, or a solid color.

**Can the Image to 3D node 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 such as Unity and Unreal, start with the low-poly or stylized backends, which produce game-ready geometry directly. For hero assets where polycount matters less, high-detail backends give better surface accuracy. To combine both, generate a high-detail mesh, retopologize to a low-poly target, then use the Bake High-Poly to Low-Poly node to transfer detail by baking normal, albedo, roughness, metallic, and ambient occlusion maps onto the low-poly mesh. The low-poly mesh must have non-overlapping UVs in the 0–1 space, and you set an explicit texture resolution for the baked maps.

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

Single-image input gives the generator only one view, so the back, top, and occluded surfaces are inferred rather than observed. Provide a cleaner, well-lit source image with depth cues to improve inference of thickness and volume on unseen surfaces.

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

Yes. Select a quad-based backend in the Image to 3D node. Quad-based meshes are suited to sculpting and retopology. For real-time rendering, triangle-based meshes are typically more efficient.

**What does the Image to 3D node output?**

The node returns a 3D preview, a wireframe preview, and a downloadable `.glb` model. You can toggle Disable PBR and Disable Texture for geometry-only output when you only need the mesh without color or material maps.

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

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) so Unreal, Unity, or Blender can request the mesh for scene assembly and procedural systems. The API approach keeps the workflow versioned and deterministic for production pipelines.


---

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