# Minable ore patches

Eighteen ore patches for The Descent, two for each of nine ore types, built on 2026-10-13 after a reference picture
from the user (four store assets: rocks with crystals and nuggets grown on them). Blender only: nothing here is
imported into Unreal and no game code was written.

Open `OrePatches.blend` (Blender 5.2). One column per ore type, the smaller A rock in front and the larger B rock
behind it; the single pieces stand in rows further back.

## How it got here

| State | The user's words | Kept in |
|---|---|---|
| 1. Rock coloured by noise, glowing veins, three ore types | *"do it more realistic with good textures"* | `versions\v01_stylised_glow` |
| 2. Scanned rock, three ore types | *"not finished create iron, copper, silver, gold, lead, platinum, titanium"* | `versions\v02_three_ores` |
| 3. Ten ore types, each with a strong look of its own | *"they are too distinct make them less"* | `versions\v03_ten_ores_distinct` |
| 4. Ten ore types as one family, ferrite a gold-coloured metal | *"ferrite is kinda iron so make it look like"* | `versions\v04_ferrite_gold_look` (the ferrite textures and pictures only) |
| 5. The same, ferrite with the iron look | *"delete the pearl how ... pearl is an ore"* | `versions\v05_with_pearl` (the set's .blend, manifest and scripts, and every pearl file) |
| 6. **This folder**: nine ore types, no pearl | | |

State 4 reads the last sentence as: too distinct from their rock and from each other. All ten now sit on the
same dark rock with only a trace of their own colour near the clusters; the pieces are smaller, sit deeper, are
duller and carry rock dust; the glow is halved again.

State 6 took pearl out and left the other nine as they were: its two patches, nine pieces, twelve textures, thirteen
FBX files and three pictures, its objects in the .blend, its entries in `OrePatches.json`, and its ore type, patches
and family of pieces (grown spheres) in the build script. The files were moved to the version folder, not destroyed.

State 5 changed twelve textures and nothing else: the ferrite atlas and the two ferrite rocks' sets. The meshes,
their UVs and the places of the clusters are the same to the last digit (the normal maps of the rebuilt ferrite
came out identical pixel for pixel), so the FBX files and `OrePatches.json` were not touched.

## What a patch is

| Part | Object | What the game does with it |
|---|---|---|
| Host rock | `SM_OreRock_<Ore>_<A/B>` | Static. Scanned dark rock; near the clusters its veins and a thin crust or stain carry the ore. Stays when the patch is mined out. |
| Ore clusters | `OrePatch_<Ore>_<A/B>_Ore_NN` (9 to 16 per patch) | **Each one is its own object**, seated in a socket of the rock. Mining takes one off and frees its `ore_units` loose chunks. |
| Collision | `UCX_SM_OreRock_..._01` | One convex hull per rock (and per cluster and chunk mesh). |
| Root | `OrePatch_<Ore>_<A/B>` (empty) | Origin on the terrain surface, **+Z points out of the rock face**. The rock goes on below z = 0; that part is buried. |

The clusters of a patch are instances of six cluster meshes per ore type (`SM_OreCluster_<Ore>_01..06`), turned
and scaled. Three loose chunk meshes per ore type (`SM_OreChunk_<Ore>_01..03`, 0.34 m, the game's chunk size) are
what flies into the suction.

Under each cluster the rock has a shallow socket of freshly broken rock with a few ore specks, so a mined-out
patch still shows where the ore was. The rock's glow is its own texture (`_E`); fade it to zero when the last
cluster is gone.

## The nine ore types

| Ore | In the game's design? | Pieces | Its trace on the rock |
|---|---|---|---|
| **Ferrite** | yes (orange) | angular lumps of dark steel-grey metal with orange rust: the iron look, on the user's word | rust crust at the clusters |
| **Cobalt** | yes (cyan) | short six-sided prisms of dark blue volcanic glass | faint blue stain |
| **Iron** | no | kidney ore: rounded dark steel-grey masses with rust | dark rust crust at the clusters |
| **Copper** | no | jagged lumps of native copper, dark green where weathered | faint green stain |
| **Silver** | no | lumpy native silver, much of it tarnished | faint pale stain |
| **Gold** | no | water-worn nuggets with dirt in their hollows | faint pale stain |
| **Lead** | no | galena: intergrown lead-grey cubes, many faces dull | faint grey stain |
| **Platinum** | no | small smooth grey grains and pebbles | hardly any |
| **Titanium** | no | rutile: short sprays of red-black needles, grooved lengthwise | faint red-brown stain |

Six of the types sit on black veined rock, three (copper, gold, platinum) on dark layered rock; the two are close in colour.

Ferrite and cobalt are the game's own (DESIGN_UE 2.12) and carry the game's glow colours. The seven metals are not in
the game's design or code yet. **The game's design and code still have a third ore type, Seam Pearl** (type 2,
magenta, with its price, depth band and recipes): it was deleted here on the user's word and has no model any more. Their glow
colours in `OrePatches.json` are a choice made here.

Six rock shapes are used: slab, twin lobes, pyramid and mound (the four of the reference picture), and a layered
shelf and ridge. Rocks of the same shape differ by their seed.

## The eighteen patches

| Patch | Rock shape | Footprint (m) | Height above / below ground (m) | Clusters | Ore units | Triangles: rock + ore = all |
|---|---|---|---|---|---|---|
| `OrePatch_Ferrite_A` | blocky slab | 1.9 x 1.7 | 1.11 / 0.31 | 11 | 15 | 4,800 + 6,516 = 11,316 |
| `OrePatch_Ferrite_B` | twin lobes | 3.4 x 2.1 | 1.11 / 0.34 | 16 | 20 | 8,112 + 9,720 = 17,832 |
| `OrePatch_Cobalt_A` | pyramid | 1.9 x 2.1 | 0.95 / 0.36 | 9 | 13 | 4,800 + 2,180 = 6,980 |
| `OrePatch_Cobalt_B` | mound with side lumps | 3.2 x 2.7 | 1.52 / 0.38 | 16 | 20 | 8,112 + 3,876 = 11,988 |
| `OrePatch_Iron_A` | blocky slab | 1.8 x 1.7 | 1.15 / 0.32 | 11 | 15 | 4,800 + 5,232 = 10,032 |
| `OrePatch_Iron_B` | mound with side lumps | 3.0 x 2.7 | 1.51 / 0.36 | 16 | 20 | 8,112 + 6,936 = 15,048 |
| `OrePatch_Copper_A` | layered shelf | 2.6 x 1.8 | 0.74 / 0.28 | 11 | 15 | 4,800 + 6,516 = 11,316 |
| `OrePatch_Copper_B` | twin lobes | 3.2 x 2.0 | 1.11 / 0.33 | 16 | 20 | 8,112 + 9,324 = 17,436 |
| `OrePatch_Silver_A` | pyramid | 2.2 x 2.0 | 0.99 / 0.39 | 9 | 13 | 4,800 + 5,112 = 9,912 |
| `OrePatch_Silver_B` | twin lobes | 3.7 x 2.1 | 1.21 / 0.34 | 16 | 20 | 8,112 + 8,136 = 16,248 |
| `OrePatch_Gold_A` | blocky slab | 1.8 x 1.5 | 1.19 / 0.31 | 11 | 15 | 4,800 + 5,328 = 10,128 |
| `OrePatch_Gold_B` | layered ridge | 3.5 x 1.8 | 1.07 / 0.32 | 16 | 20 | 8,112 + 6,948 = 15,060 |
| `OrePatch_Lead_A` | pyramid | 2.0 x 1.9 | 0.90 / 0.35 | 9 | 13 | 4,800 + 636 = 5,436 |
| `OrePatch_Lead_B` | mound with side lumps | 3.2 x 2.7 | 1.53 / 0.36 | 16 | 20 | 8,112 + 864 = 8,976 |
| `OrePatch_Platinum_A` | layered shelf | 2.4 x 2.0 | 0.82 / 0.28 | 11 | 15 | 4,800 + 6,804 = 11,604 |
| `OrePatch_Platinum_B` | layered ridge | 3.3 x 2.1 | 1.18 / 0.34 | 16 | 20 | 8,112 + 9,612 = 17,724 |
| `OrePatch_Titanium_A` | blocky slab | 2.3 x 1.5 | 0.89 / 0.30 | 11 | 15 | 4,800 + 2,000 = 6,800 |
| `OrePatch_Titanium_B` | twin lobes | 3.4 x 2.1 | 1.08 / 0.34 | 16 | 20 | 8,112 + 2,848 = 10,960 |

Triangles of the single pieces (least to most):

| Ore | Clusters | Loose chunks |
|---|---|---|
| Ferrite | 432 to 840 | 300 to 300 |
| Cobalt | 184 to 300 | 48 to 68 |
| Iron | 300 to 708 | 408 to 408 |
| Copper | 432 to 948 | 300 to 408 |
| Silver | 324 to 840 | 300 to 408 |
| Gold | 324 to 840 | 300 to 300 |
| Lead | 36 to 120 | 24 to 48 |
| Platinum | 432 to 864 | 300 to 300 |
| Titanium | 160 to 224 | 32 to 64 |

All meshes: quads (crystal tips and base caps are triangles), no n-gons, no open edges, no zero-area faces, one UV
map. No booleans were used.

## Files

| Path | What |
|---|---|
| `OrePatches.blend` | Scene `Ore Patches`: collections `Patches`, `Library`, `Collision` (hidden), `Studio` (camera, lights, ground; not exported). |
| `OrePatches.json` | The layout for the game: the ore types, and per patch the rock mesh, its textures and every cluster (mesh, position, normal, rotation, scale, units). Metres, Z up, right-handed; for Unreal multiply by 100 and flip Y. |
| `fbx\SM_*.fbx` | 99 files: 18 rocks, 54 clusters, 27 chunks, each at the origin with its `UCX_` hull. Triangulated on export (the .blend keeps quads). |
| `fbx\assembled\OrePatch_*.fbx` | 18 files: a whole patch with its clusters in place, for a quick look or for dressing a scene. |
| `textures\T_OreRock_<Ore>_<A/B>_{BC,N,ORM}.png` | **4096 px**, one set per rock (`_E` is 2048 px). |
| `textures\T_Ore_<Ore>_{BC,N,ORM,E}.png` | 2048 px, one atlas per ore type for its six clusters and three chunks. |
| `source_textures\` | The three scanned rock sets the rocks are baked from (see below). Not needed by the game. |
| `previews\` | A render of each patch, `OrePatches_sheet.png` (all eighteen, four to a row), `OrePatch_mining_stages.png` (full, half mined, mined out), `OrePieces_<Ore>.png` (the nine pieces of each type). |
| `build\` | `build_ore_patches.py` (builds everything headless), `verify_fbx.py` (reads every FBX back), `check_fit.py` (seating and crossing check), their reports, and three tools that change a built set without building it again: `rerender.py` (pictures), `remove_ore.py` (takes an ore type out), `reseat.py` (the seating rule; not needed after a build with the current script). |
| `versions\` | The five earlier states listed above (1.7 GB together; delete what is not wanted). |

## Where the textures come from

The rock surfaces are scans from **Poly Haven** (polyhaven.com), licence **CC0**: free for commercial use, no
credit required. Downloaded on 2026-10-13 with the user's permission, 9 files, 17.5 MB:

| Set | Scanned area | Used for | Files |
|---|---|---|---|
| `dark_rock` (Amal Kumar) | 2.42 m | ferrite, cobalt, iron, silver, lead and titanium rocks | `_diff_2k.jpg`, `_rough_2k.jpg`, `_disp_2k.exr` |
| `dark_rock_02` (Amal Kumar) | 2.0 m | copper, gold and platinum rocks | the same three |
| `rock_05` (Rob Tuytel) | 1.5 m | the crust at the clusters of ferrite and iron rocks | the same three |

Each scan is projected from three sides at its real size onto a 153,600-quad copy of the rock and baked into that
rock's own UV set, so the game needs only the baked textures. Everything else is made here: the rock shapes, the
ore pieces and their surfaces, and the masks that put crust, stain, dust and ore into the rock.

The preview lighting uses Blender's own `studio.exr` (packed into the .blend).

## Textures in Unreal

- `_BC` base colour (sRGB), `_E` emissive colour (sRGB), `_ORM` ambient occlusion / roughness / metallic in R / G / B
  (sRGB off), `_N` normal map in Unreal's convention (green down; leave "Flip Green Channel" off).
- The emissive textures are tinted with the ore's glow colour and are deliberately sparse and faint (ore in the
  rock's veins, specks in the sockets, the hollows of the pieces). The strength is the material's number: the
  .blend uses 0.5 on rocks and 0.3 on ore. In the dark of the game this is the cue that tells the types apart, so
  expect to raise it there.
- Import the FBX files with normals imported and tangents computed (MikkTSpace); they carry the triangulation
  the normal maps were baked on.

## Rebuilding

```
blender -b --factory-startup --python build\build_ore_patches.py
blender -b --factory-startup --python build\verify_fbx.py
blender -b OrePatches.blend --python build\check_fit.py
```

`-- --quick` builds a small test set into `build\_quick`, `-- --only Iron_A,Gold_B` builds some patches only.
An ore type is one entry in `ORES` at the top of the script: the rock it sits on, its crust or stain, its family
of pieces (`nugget`, `prism`, `cube`) and that family's numbers. A patch is one line in `PATCHES`: ore,
rock shape, seed. Building the whole set took 29 minutes with another Blender sharing the GPU.

To change one ore type's look without building everything: build it into a side folder
(`-- --only Ferrite_A,Ferrite_B --out build\_side --no-render`), copy its textures over those in `textures\`, and
render its pictures again with `blender -b OrePatches.blend --python build\rerender.py -- Ferrite`.

The files in this folder come from a build with all seeds fixed (numpy's and Blender's noise). That the script
gives them again was tested on seven of the eighteen patches (same cluster places; for ferrite also identical
normal maps), not by building the whole set twice. The earlier states in
`versions\` were built before Blender's noise seed was fixed and cannot be rebuilt exactly.

## Limits

- Not in the Unreal project. The game still draws its veins in the terrain material and builds its loose chunk
  in code; nothing reads `OrePatches.json` yet.
- The seven metals are models only: the game has no such ore types, so using them is a design decision first
  (what they are worth, where they lie, what is made from them).
- With the types this close, silver and platinum are hard to tell apart at a glance. Ferrite and iron look alike
  on purpose: the same steel-grey and rust, ferrite in angular lumps with a slightly warmer rust, iron in rounded
  kidney masses. In the game the glow colour and the HUD would have to tell them apart.
- No LODs and no lightmap UVs.
- The cobalt glass is opaque in these textures. Light passing through it would need a
  translucent or subsurface material in Unreal; that is a material choice there, not a texture.
- One convex hull per rock: a twin-lobed rock has an invisible bridge over the saddle between its lobes.
- The game's terrain is not made from these scans, so a patch will only sit in the terrain as well as the two
  rock colours agree; the rock's colour can be shifted in the material.
- The preview renders use the game meshes and the baked textures under studio light; under the Tender's lamp in
  dark water they will look darker.