from dataclasses import dataclass
import numpy as np

@dataclass
class UvBounds:
    min_u: float
    max_u: float
    min_v: float
    max_v: float

def get_uv_bounds(uvs: np.ndarray) -> UvBounds:
    """Calculate UV bounds from mesh UV coordinates."""
    return UvBounds(
        min_u=float(np.min(uvs[:, 0])),
        max_u=float(np.max(uvs[:, 0])),
        min_v=float(np.min(uvs[:, 1])),
        max_v=float(np.max(uvs[:, 1]))
    )

import math

def calculate_texture_resolution(
    mesh_area: float,
    uv_bounds: UvBounds,
    target_density: float
) -> tuple[int, int]:
    """Calculate optimal texture resolution for mesh."""
    desired_texels = math.sqrt(mesh_area * target_density**2)
    uv_coverage = (uv_bounds.max_u - uv_bounds.min_u) * (uv_bounds.max_v - uv_bounds.min_v)
    size = desired_texels / math.sqrt(uv_coverage)

    # Round to next power of 2, clamp to 64-512
    size = 2 ** math.ceil(math.log2(size))
    size = max(64, min(512, size))

    return (size, size)

1. Generate mesh with UVs (procedural-meshes)
2. Calculate texture resolution (64 texels/unit)
3. Identify UV regions (body, head, limbs)
4. Generate albedo (skin + clothing)
5. Generate MRE/SSE (per-region roughness)
6. Export coordinated set

1. Generate individual textures for props
2. Pack into atlas using shelf algorithm
3. Remap mesh UVs to atlas coordinates
4. Export single atlas + remapped meshes

# Character with coordinated textures
[[assets.meshes]]
id = "player"
path = "generated/meshes/player.gltf"

[[assets.textures]]
id = "player_albedo"
path = "generated/textures/player_albedo.png"

# Atlased props (single texture for multiple meshes)
[[assets.textures]]
id = "props_atlas"
path = "generated/textures/props_atlas.png"

[[assets.meshes]]
id = "crate"
path = "generated/meshes/crate.gltf"  # UVs remapped to atlas