> For the complete documentation index, see [llms.txt](https://docs.m-xr.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.m-xr.com/marso-studio/workflows/make-a-material-from-an-image.md).

# Make a material from an image

Turn a flat image of a surface, such as a brick wall, a stone floor, a fabric or a wood grain, into a PBR material. I2M predicts five maps from it: **albedo**, **metallic**, **roughness**, **IOR** and **normal**. You can add a **displacement** map too.

The result is a material, not a 3D model. Use it on your own models, or repeat it across a floor, a wall or a terrain.

There are two ways to make one:

* **The Texture app** is the quickest. Give it an image, or describe the surface, and it runs everything for you. See [Using the Texture app](#using-the-texture-app).
* **The Generate PBR Textures node** gives you a graph you can build on, for example with **Edit Image** before the material. See [Using the node](#using-the-node).

Both take the same choices and cost the same.

## Choosing an image

The maps can only be as good as the image. The best images:

* look straight at the surface, not at an angle
* are lit evenly, with no strong shadows or bright highlights
* show the surface alone, with no objects, edges or background in the frame

The image can be a PNG, JPG or WebP, up to 20 MB and at most **2048 pixels on each side**. A bigger image is refused, not shrunk, so resize it before you start.

## Choosing a tiling mode

**Tiling** decides whether the material repeats. Ask yourself whether the image already repeats with no visible seam:

| Your image                                       | Pick              | What happens                                                                              |
| ------------------------------------------------ | ----------------- | ----------------------------------------------------------------------------------------- |
| A photo, or anything you won't repeat            | **Not tiled**     | A material from the image as it is                                                        |
| Already repeats with no visible seam             | **Already tiled** | The maps tile without a seam at their edges too                                           |
| Should repeat, but shows a seam when you tile it | **Make tileable** | A separate model makes the image repeat first, then I2M predicts the maps from the result |

**Make tileable can change the image's size and shape.** To make it repeat, it can add bands where the seams were, or crop it to whole repeats. The maps can come back at a different size or aspect ratio from the image you gave it. Make tileable adds 10 credits.

## Using the Texture app

1. Click **Apps** in the left sidebar and choose **Texture**.
2. Start from an **Image**: drop or choose one, or pick one from your library. Or start from **Text**: describe the surface, such as *Weathered red brick with pale mortar*. From text, the app makes the image first.
3. Pick a **Tiling** mode, and tick **Displacement** if you want a height map.
4. Check the price beside **Generate**, then press it.

The app shows each stage as it runs. When it's done, **Open the library** opens the material. Every run is an ordinary project, so you can open it in the node editor and carry on by hand. See [Apps](/marso-studio/workflows/apps.md).

## Using the node

1. On **Home**, click **Create Project** and choose **Blank**.
2. From **Add** on the canvas toolbar, add a **Load Image** node and upload your image. To generate one instead, add **Generate Image** and describe the surface.
3. Add a **Generate PBR Textures** node and connect the image to its input, **3D model or image**.
4. On the node, pick a **Tiling** mode, and tick **Displacement** if you want a height map. The node shows the price.
5. Click **Run PBR Texture Generation**.

A finished node keeps its result. To try another tiling mode, or to add displacement, add a new **Generate PBR Textures** node and run that.

## Checking the result

Hover the node and click **View preview**, or open the material from your library. A material made from an image shows on a flat plane.

* **Tiled**, at the top left of the viewer, repeats the material three times each way. Turn it on to check that the edges join with no visible seam. It's the quickest way to check a tiling mode did what you wanted.
* Click a map's thumbnail in the bar along the bottom to see that map on its own, or **View layer** to see it as a flat image.
* Change the HDRI to see how the material catches different light.

A displacement map shows as a grey layer you can view on its own. The preview stays flat: it doesn't move the surface by the displacement map.

## The maps you get

Each map is a PNG file. Connect each one to the matching input of the material in your renderer or engine:

| Map              | What it holds                                                                                                    | Connect it to                                      |
| ---------------- | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| **Albedo**       | The colour of the surface, with no shadow or highlight in it                                                     | Base colour                                        |
| **Metallic**     | Which parts are bare metal                                                                                       | Metallic                                           |
| **Roughness**    | How smooth or rough each point is, from a sharp highlight to a soft sheen                                        | Roughness                                          |
| **IOR**          | How much the surface reflects when you look at it head-on, on a 0 to 1 scale                                     | Specular, or IOR (some materials need it remapped) |
| **Normal**       | Fine detail, such as grain, cracks and stitching, as 8-bit RGB                                                   | Normal map                                         |
| **Displacement** | How high or low each point of the surface is, as a 16-bit greyscale image. Only when you ticked **Displacement** | Height or displacement                             |

The normal map uses the OpenGL convention (green up). If your engine expects the DirectX convention, flip its green channel.

Treat albedo as colour data, and metallic, roughness, IOR, normal and displacement as non-colour data.

## Using displacement

The normal map makes a surface look detailed while it stays flat. Displacement goes further: your renderer moves the geometry by it, so mortar joints sink, stones stand up, and the silhouette at the edge shows their shape.

Three things to know:

* **The surface needs enough geometry to move.** A plane with four corners can't show any relief. Subdivide it, or use your renderer's tessellation or displacement settings.
* **You set the depth.** The map tells how high each point is compared with the others, from black (lowest) to white (highest). It holds no real-world scale, so set the strength in your renderer, from a subtle relief to an exaggerated one.
* **Use it with the normal map, not instead of it.** Displacement gives the large shapes, and the normal map the fine detail on top.

Displacement adds 10 credits. If a surface is mostly flat, such as a smooth plaster or a fabric, the normal map alone is often enough.

## What it costs

**35 credits** for an image up to 1 megapixel (1,048,576 pixels), and **40** above that. **Make tileable** adds **10**, and **Displacement** adds **10**. **Not tiled** and **Already tiled** add nothing. The price uses the size of the image you gave it, even when Make tileable changes the canvas. In the Texture app, starting from text adds 10 for the image. See [Credits & billing](/marso-studio/reference/credits-and-billing.md).

## Download it

**Download Textures** on the node, the download button in the viewer, or **Download** in your library gives you the maps as PNG files: albedo, metallic, roughness, IOR and normal, plus displacement if you ticked it. There's no 3D model in this route, so there's no `.usdz`. Downloads need a paid plan or the trial: see [Plans](/marso-studio/reference/credits-and-billing.md#plans).

## Every image in a group

**Generate PBR Textures (Group)** makes a material from every image in a Reference Images group, at 30 credits an image. See [Generate PBR Textures (Group)](/marso-studio/reference/nodes-reference.md#generate-pbr-textures-group).

## From the API

Send the image to `POST /pbr/execute/image`, with your choices in `options`:

```json
{"asset_id": "<ready-image-id>", "options": {"tiling_mode": "make_tileable", "displacement": true}}
```

* `tiling_mode` is `non_tiled` (the default), `already_tiled` or `make_tileable`.
* `displacement` is `true` or `false` (the default).
* The older `"tileable": true` still works, and means `already_tiled`. Send `tileable` or `tiling_mode`, not both: a request with both is refused.
* `POST /batch/pbr/image`, for several images at once, takes `tileable` only. It refuses `tiling_mode` and `displacement`.
* Marso MCP takes the same `tiling_mode` and `displacement` choices when your agent runs the node.

See [PBR](https://docs.m-xr.com/marso-studio-api/api/pbr) in the API reference, and [API access](/marso-studio/api/api-access.md) for a key.


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.m-xr.com/marso-studio/workflows/make-a-material-from-an-image.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.