> ## Documentation Index
> Fetch the complete documentation index at: https://docs.summerengine.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Tileable texture skill for AI agents

> Generate a seamless tileable texture for walls, floors or terrain, wired as a StandardMaterial3D albedo. A Summer Engine skill for AI agents.

`tileable-texture` is a skill from the [Summer skill library](/mcp/skills): a guide your AI agent reads when the task matches, so it builds the good version on the first try. Generate a seamless tileable texture for walls, floors or terrain, wired as a StandardMaterial3D albedo.

| | |
| - | - |
| Status | Stable |
| Domains | 2D art, Asset pipeline |
| Version | `1.0.4` |
| Engine version | `>=4.6` |
| Recommended set | No, installed by `--all` or by name |

## When your agent uses it

* Generating a seamless tileable texture for walls, floors, terrain, or ceilings — a square tile that repeats cleanly on all four edges
* A wall, floor, or terrain material shows visible seams or repetition and needs a texture that tiles cleanly

## Install

`summer setup` installs every skill for your agent. To add only this one:

```bash theme={null}
npx -y summer-engine@latest skills install tileable-texture --agent claude-code
```

Swap `claude-code` for your agent, such as `codex` or `cursor`. See [Skills](/mcp/skills#quick-start) for every option.

## The skill

This skill generates a seamless square texture (typically 1024×1024) that tiles cleanly on all four edges with no visible seams. Output goes onto a `PlaneMesh`, `CSGBox3D`, or `MeshInstance3D` as a `StandardMaterial3D` albedo, often with `uv_scale` cranked up so a single tile covers a small area and the surface repeats it across a wall or floor.

The hard part is "seamless." Most diffusion models violate edge continuity by default — generate a brick wall and the bricks stop mid-row at the edge. This skill encodes the prompt suffix and the post-import verification that catches seams before they ship.

## When to use

* "Generate a brick wall texture for this room."
* "I need a grass ground texture for the level."
* "Tileable wood-floor texture, 1024×1024."
* "Stone tile texture for the dungeon."
* "Sand / dirt / metal-panel — seamless."

## When NOT to use

* The user wants a 3D-modeled wall with geometric brick relief → `asset-strategy` (image-to-3D).
* The user wants a unique mural / non-tiling artwork → `concept-art` or `character-portrait`.
* The user wants a skybox / 360° environment → `skybox-panorama`.
* The user wants a normal map / PBR material set — generation today is albedo-only. Normals must be derived (`MaterialMaker`, `NormalMap-Online`) or hand-authored.

## Steps

### 1. Search for an existing texture

```
assets.search({ query: "<material> tileable", assetType: "2d_image", scope: "all" })
```

Texture libraries (AmbientCG, Polyhaven) often have free PBR sets that beat AI generation for realism. If the user wants photorealistic tiling, pause and suggest those.

### 2. Build the prompt — material + the seamless suffix

Pattern:

```
<material description>, seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no edges, square format, no specific objects in frame
```

The load-bearing phrases are:

* **`seamless tileable texture`** — primes the model.
* **`top-down view`** — kills perspective convergence (which is the #1 source of visible seams).
* **`uniform lighting`** — kills directional shadows that bake into the tile and stripe across the surface when it repeats.
* **`no perspective, no shadows, no edges`** — explicit negation of common failure modes.
* **`no specific objects in frame`** — kills "interest" features the model adds (a single bright leaf, a chip in one brick) that scream "this is a repeating tile."

### 3. Generate

```
assets.generate_image({
  prompt: "weathered red brick wall, seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no specific objects, square format, photographic detail. No vanishing point, no directional shadow, no vignette, no single standout feature, no scene context, no sky, no sun.",
  model: "nano-banana-2",
  style: "realistic"
})
```

Two things about the arguments:

* **There is no `image_size` and no `negative_prompt`.** `assets.generate_image` takes `prompt`, `model`, `style`, `aspectRatio`, `width`, `height`, `numImages`, `referenceImageUrl`, `removeBackground`, `seed` and `title`; a field it does not list does nothing, so the call looks like it worked. Put the negations in the prompt text. Leave `aspectRatio` at its `1:1` default, which is exactly what a tileable texture wants; for a larger tile, leave `model` out and pass `width` and `height`: a model that reaches the size is picked, or the answer names the models that can.
* **`style: "realistic"` is a no-op.** Only `cartoon` and `anime` append anything to the prompt; `realistic` and `none` append nothing, and any other value is coerced to `none`. The photographic look has to come from the prompt (`photographic detail`). Switching to `"none"` for stylized work likewise changes nothing on its own — change the prompt.

### 4. Import to project

```
summer_import_from_url(url="<fileUrl>", path="res://art/textures/brick_red.png")
```

In the import dock, set:

* `Repeat: Enabled` (REQUIRED for tiling).
* `Filter: Linear with mipmaps` (smoother at distance).
* `Mipmaps: Enabled` (textures viewed at angle need mipmaps).
* `Compress: VRAM Compressed` for ship; `Lossless` while iterating.

### 5. Verify the seam

Before wiring into a scene, view the texture tiled. Quick check: in the editor's filesystem dock, right-click the texture → preview → set repeat 4×4 mentally. Or apply to a `PlaneMesh` with `uv_scale = (4, 4)` and look from above.

If you see a grid of identical "interest features" (a chip, a stain, a bright pixel) repeating, the tile has a hotspot — regenerate with stronger negative on "single feature."

If you see hard horizontal/vertical seams, the edges don't match — regenerate with extra emphasis on `seamless` or run the texture through a seamless-tile filter (Photoshop "Offset" + heal, GIMP "Make Seamless", or Aseprite's Tiled Mode).

### 6. Wire onto geometry

**On a PlaneMesh (floor/ceiling):**

Every scene-mutating tool takes an explicit `scenePath`; node paths are relative to that scene's root (`./`); `summer_set_prop`'s property argument is named `key`; and `summer_set_resource_property` needs all five of `scenePath`, `nodePath`, `resourceProperty`, `subProperty`, `value` (there is no two-argument form and no `"mesh:size"` colon-path form).

Assigning a bare class name to a resource property auto-instantiates it, so the mesh comes first:

```
summer_add_node(scenePath="res://levels/level_01.tscn", parent="./Level", type="MeshInstance3D", name="Floor")
summer_set_prop(scenePath="res://levels/level_01.tscn", path="./Level/Floor", key="mesh", value="PlaneMesh")
summer_set_resource_property(scenePath="res://levels/level_01.tscn", nodePath="./Level/Floor", resourceProperty="mesh", subProperty="size", value="Vector2(20, 20)")
```

Then the material. `material_override` is a `Material`, and `StandardMaterial3D` is the class name that auto-instantiates:

```
summer_set_prop(scenePath="res://levels/level_01.tscn", path="./Level/Floor", key="material_override", value="StandardMaterial3D")
summer_set_resource_property(
  scenePath="res://levels/level_01.tscn",
  nodePath="./Level/Floor",
  resourceProperty="material_override",
  subProperty="albedo_texture",
  value="res://art/textures/brick_red.png"
)
summer_set_resource_property(
  scenePath="res://levels/level_01.tscn",
  nodePath="./Level/Floor",
  resourceProperty="material_override",
  subProperty="uv1_scale",
  value="Vector3(20, 20, 1)"
)
summer_save_scene(scenePath="res://levels/level_01.tscn")
```

`uv1_scale = (20, 20, 1)` on a 20m plane means the texture tiles 20× across — each tile covers 1m².

**On a CSGBox3D (walls):**

```
summer_add_node(scenePath="res://levels/level_01.tscn", parent="./Level", type="CSGBox3D", name="WallNorth")
summer_set_prop(scenePath="res://levels/level_01.tscn", path="./Level/WallNorth", key="size", value="Vector3(10, 3, 0.3)")
```

Then attach the same material with `uv1_scale` tuned to wall dimensions.

## Prompt patterns

| Goal | Prompt that works | Why |
| - | - | - |
| Brick wall | `weathered red brick wall, seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no specific objects, square, photographic` | Top-down + uniform lighting kill perspective seams |
| Grass ground | `dense fresh grass, seamless tileable texture, top-down view, uniform lighting, no shadows, no flowers, no patches, square` | "No flowers, no patches" kills hotspot features |
| Wood floor | `oak wood floor planks, seamless tileable, top-down view, uniform lighting, no perspective, no nails, no knots emphasized, square` | "No knots emphasized" kills the ONE bright knot per tile |
| Stone tiles | `cobblestone path, seamless tileable, top-down, uniform lighting, no shadows, no moss patches, square, photographic` | "No moss patches" kills hotspot |
| Metal panel | `industrial metal floor panel, seamless tileable, top-down, uniform lighting, no rust hotspots, no scratches concentrated, square` | Diffuse rust spreads across the tile instead of clumping |
| Sand / dirt | `dry desert sand, seamless tileable, top-down view, uniform soft lighting, no footprints, no rocks, no shadows, square` | Negative space is ideal for tiling |
| Stylized painterly grass | `stylized painterly grass, Studio Ghibli, seamless tileable, top-down, uniform lighting, no specific blades emphasized, square` | The painterly direction has to be in the prompt; no `style` value produces it |
| Sci-fi panel | `sci-fi metal floor panel with subtle glowing seams, seamless tileable, top-down, uniform lighting, square, the glowing seams form a regular grid that aligns with tile edges` | Make the seams part of the design |

### Bad prompts (and why)

| Bad | Failure mode |
| - | - |
| `brick wall` | No "seamless," no "top-down." Returns a 3D-photographed wall with perspective and a corner. Useless for tiling. |
| `seamless brick wall in a dungeon at night` | Scene context bakes shadows and ambience that won't tile. |
| `tileable grass with flowers and rocks` | Hotspot features. Each tile has the SAME flower. Visible repeat. |
| `seamless wood floor (not specifying square / top-down)` | Often returns floor-from-eye-level with perspective. |
| `pbr wood floor texture` | "PBR" implies a material set (albedo + normal + roughness). The model only outputs albedo. Generate albedo, derive maps separately. |

## Anti-patterns

* **Skipping `Repeat: Enabled` on import.** Default is `Repeat: Disabled`. The texture stretches across the whole surface instead of tiling. Looks blurry at distance.
* **Not tuning `uv1_scale`.** Default scale of (1, 1, 1) on a 20m floor means the 1m-real texture is stretched to 20m. Always scale to physical sizing.
* **Hotspot features** that scream "repeated tile." Regenerate with stronger negative on single-feature words.
* **Generating PBR sets with one image.** Diffusion outputs albedo only. For normals/roughness, use a derivation tool or hand-author. Don't claim it's PBR-ready when it's not.
* **Forgetting mipmaps.** Tileable textures viewed at distance need mipmaps; without them, you get shimmering moire.
* **Using textures with directional shadow** baked in. Even subtle shadow stripes when tiled. Always demand "uniform lighting."

## Edge cases

* **User wants normal map / roughness / AO too.** Generation today produces albedo only. Use `Materialize` (free) or `MaterialMaker` (open source) to derive a normal from the albedo. Hand-paint roughness if the surface is heterogeneous (wood = low roughness on knots, high on grain). Set the user's expectation: AI gives albedo; PBR is a follow-up step.
* **Texture must tile in only one direction (e.g., a brick wall that runs horizontally but not vertically).** Generate 1024×1024 seamless, then crop to your actual aspect; the horizontal tile remains seamless. Or: prompt `tileable horizontally only, distinct top and bottom edges` for ceiling-to-floor walls.
* **Texture must read at very low resolution (mobile, distant LOD).** You cannot request a generation size over MCP anyway — take the default and downscale on import (`Compress: VRAM Compressed`, or set a smaller size in the import dock).
* **User wants animated water / lava texture.** Generate a still tileable texture and use a `ShaderMaterial` with UV scrolling to animate. Don't try to generate frames.
* **Visible seam after generation.** Run through GIMP `Filters → Map → Make Seamless` or open in Aseprite, set Tiled mode, paint over the seam manually. AI-generated tileables often need a 5-minute touch-up.

## Without Summer Engine

In a session without Summer Engine tools (the assets profile; the `summer-assets` skill has the whole loop), do steps 1-3 and the seam check in step 5 by eye on the image (tile it 2x2 in an image viewer); skip step 4 and step 6 (import, wiring onto geometry). Pass `out` with the person's folder so the PNG lands there (the `summer-assets` skill says how), and tell them to set the texture to repeat.

## Fallback (no MCP)

Print the call:

```
assets.generate_image({
  prompt: "<material> seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no specific objects, square. No directional shadow, no single standout feature, no scene context.",
  model: "nano-banana-2",
  style: "realistic"
})
```

Tell the user to run via the Summer dashboard, then `summer_import_from_url` to `res://art/textures/<name>.png`, set `Repeat: Enabled`, and tune `uv1_scale` to physical size.

If MCP is offline entirely: AmbientCG and Polyhaven offer free CC0 PBR texture sets that often beat AI for realism. For stylized, hand-author in Aseprite/Krita with tile-mode preview.

## Handoff

After the texture is wired:

* **More textures in the same biome** → re-invoke this skill, hold style/lighting consistent.
* **Apply to a procedurally-built level** → `scene-composition` for CSG and modular wall kits.
* **PBR set with normals/roughness** → out of MCP scope today; user runs derivation in MaterialMaker.
* **Skybox for the level's environment** → `skybox-panorama`.

## See also

* `asset-strategy` — meta-router and 3D pipeline.
* `skybox-panorama` — sky/environment counterpart.
* `scene-composition` — applying textures to CSG and MeshInstance3D.
* `summer_docs_read` id `reference/mcp-tools-reference` — how to call `assets.generate_image`.

## From a shell

No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.

| In this skill | Command |
| - | - |
| `assets.generate_image`, `summer_assets_generate_image` | `summer assets generate-image` |
| `summer_assets_search` | `summer assets search` |
| `summer_docs_read` | `summer docs read` |
| `summer_add_node` | `summer engine add-node` |
| `summer_import_from_url` | `summer engine import-from-url` |
| `summer_inspect_node` | `summer engine inspect-node` |
| `summer_save_scene` | `summer engine save-scene` |
| `summer_set_prop` | `summer engine set-prop` |
| `summer_set_resource_property` | `summer engine set-resource-property` |

## Related skills

* [`character-portrait`](/skills/character-portrait): Generate one polished character bust for dialogue UI, character select, lore cards or codex entries.
* [`concept-art`](/skills/concept-art): Explore art direction with 3-4 rough concept variants of a character, environment or prop.
* [`skybox-panorama`](/skills/skybox-panorama): Generate a 360-degree sky panorama and wire it as a PanoramaSkyMaterial Sky resource on WorldEnvironment.
* [`asset-strategy`](/skills/asset-strategy): Route any 'I need a \[thing]' asset request to the right skill: 2D, 3D, audio, video, VFX or animation.
* [`create-asset-sheet`](/skills/create-asset-sheet): Generate a pack of 2D assets from one prompt (tile sheet, UI kit, character pack, biome), sliced.

***

Source: [`library/skills/tileable-texture/SKILL.md`](https://github.com/SummerEngine/summer/blob/main/library/skills/tileable-texture/SKILL.md), rendered from `summer-engine@4.3.0` on npm.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.