| |
| """Render an isometric floor view of a Quake 1 BSP map to PNG. |
| |
| Reads the world model's faces straight from the BSP (version 29), keeps the |
| upward-facing surfaces (floors, stairs, ledges), projects them isometrically |
| and colours them by height in a Quake-style palette. Liquids are drawn blue, |
| sky and tool brushes are skipped. |
| |
| python3 tools/render_map.py quake/maps/bsp/aerowalk.bsp out.png "Aerowalk" |
| """ |
| import math |
| import struct |
| import sys |
|
|
| from PIL import Image, ImageDraw, ImageFilter, ImageFont |
|
|
| W, H, SS = 960, 600, 2 |
| BG_TOP, BG_BOTTOM = (28, 20, 16), (10, 8, 7) |
| LOW, MID, HIGH = (110, 40, 20), (205, 105, 35), (255, 214, 120) |
| LIQUID = (40, 110, 150) |
|
|
|
|
| def lumps(data): |
| version = struct.unpack_from("<i", data, 0)[0] |
| if version != 29: |
| raise SystemExit(f"not a Quake 1 BSP (version {version})") |
| return [struct.unpack_from("<ii", data, 4 + 8 * i) for i in range(15)] |
|
|
|
|
| def texture_names(data, ofs, length): |
| count = struct.unpack_from("<i", data, ofs)[0] |
| names = [] |
| for i in range(count): |
| mofs = struct.unpack_from("<i", data, ofs + 4 + 4 * i)[0] |
| if mofs < 0: |
| names.append("") |
| continue |
| raw = data[ofs + mofs: ofs + mofs + 16] |
| names.append(raw.split(b"\0", 1)[0].decode("latin-1").lower()) |
| return names |
|
|
|
|
| def load_floors(path): |
| data = open(path, "rb").read() |
| L = lumps(data) |
| planes = [struct.unpack_from("<4fi", data, L[1][0] + 20 * i) for i in range(L[1][1] // 20)] |
| verts = [struct.unpack_from("<3f", data, L[3][0] + 12 * i) for i in range(L[3][1] // 12)] |
| texinfo_tex = [struct.unpack_from("<i", data, L[6][0] + 40 * i + 32)[0] for i in range(L[6][1] // 40)] |
| names = texture_names(data, *L[2]) |
| edges = [struct.unpack_from("<2H", data, L[12][0] + 4 * i) for i in range(L[12][1] // 4)] |
| surfedges = struct.unpack_from(f"<{L[13][1] // 4}i", data, L[13][0]) |
| first_face, num_faces = struct.unpack_from("<2i", data, L[14][0] + 56) |
|
|
| floors = [] |
| for f in range(first_face, first_face + num_faces): |
| planenum, side, firstedge, numedges, texinfo = struct.unpack_from("<HHiHH", data, L[7][0] + 20 * f) |
| name = names[texinfo_tex[texinfo]] if texinfo_tex[texinfo] < len(names) else "" |
| if name.startswith(("sky", "trigger", "clip", "hint", "skip")): |
| continue |
| nz = planes[planenum][2] * (-1 if side else 1) |
| liquid = name.startswith("*") |
| if nz < 0.7 and not liquid: |
| continue |
| poly = [] |
| for e in surfedges[firstedge: firstedge + numedges]: |
| a, b = edges[abs(e)] |
| poly.append(verts[a if e >= 0 else b]) |
| floors.append((poly, liquid)) |
| return floors |
|
|
|
|
| def lerp(c1, c2, t): |
| return tuple(int(a + (b - a) * t) for a, b in zip(c1, c2)) |
|
|
|
|
| def height_colour(t): |
| return lerp(LOW, MID, t * 2) if t < 0.5 else lerp(MID, HIGH, (t - 0.5) * 2) |
|
|
|
|
| def render(path, out, title=""): |
| floors = load_floors(path) |
| yaw, pitch = math.radians(45), math.radians(35) |
| cy, sy, cp, sp = math.cos(yaw), math.sin(yaw), math.cos(pitch), math.sin(pitch) |
|
|
| def project(v): |
| x, y, z = v |
| rx, ry = x * cy - y * sy, x * sy + y * cy |
| return rx, -(ry * sp) - z * cp, ry * cp - z * sp |
|
|
| zs = [v[2] for poly, _ in floors for v in poly] |
| zmin, zmax = min(zs), max(zs) |
| items = [] |
| for poly, liquid in floors: |
| pts = [project(v) for v in poly] |
| depth = sum(p[2] for p in pts) / len(pts) |
| z = sum(v[2] for v in poly) / len(poly) |
| items.append((depth, [(p[0], p[1]) for p in pts], z, liquid)) |
|
|
| xs = [x for _, pts, _, _ in items for x, _ in pts] |
| ys = [y for _, pts, _, _ in items for _, y in pts] |
| margin = 0.08 |
| scale = min(W * (1 - 2 * margin) / (max(xs) - min(xs)), |
| H * (1 - 2 * margin - 0.08) / (max(ys) - min(ys))) * SS |
| ox = (W * SS - (max(xs) - min(xs)) * scale) / 2 - min(xs) * scale |
| oy = (H * SS - (max(ys) - min(ys)) * scale) / 2 - min(ys) * scale + H * SS * 0.03 |
|
|
| img = Image.new("RGB", (W * SS, H * SS)) |
| bg = ImageDraw.Draw(img) |
| for row in range(H * SS): |
| bg.line([(0, row), (W * SS, row)], fill=lerp(BG_TOP, BG_BOTTOM, row / (H * SS))) |
|
|
| |
| shadow = Image.new("L", img.size, 0) |
| sd = ImageDraw.Draw(shadow) |
| for _, pts, _, _ in items: |
| sd.polygon([(x * scale + ox + 14 * SS, y * scale + oy + 22 * SS) for x, y in pts], fill=150) |
| shadow = shadow.filter(ImageFilter.GaussianBlur(12 * SS)) |
| img.paste((0, 0, 0), mask=shadow) |
|
|
| draw = ImageDraw.Draw(img) |
| for depth, pts, z, liquid in sorted(items, key=lambda i: -i[0]): |
| t = (z - zmin) / ((zmax - zmin) or 1) |
| fill = LIQUID if liquid else height_colour(t) |
| draw.polygon([(x * scale + ox, y * scale + oy) for x, y in pts], |
| fill=fill, outline=lerp(fill, (0, 0, 0), 0.45)) |
|
|
| img = img.resize((W, H), Image.LANCZOS) |
| if title: |
| d = ImageDraw.Draw(img) |
| try: |
| font = ImageFont.truetype("DejaVuSans-Bold.ttf", 30) |
| small = ImageFont.truetype("DejaVuSans.ttf", 16) |
| except OSError: |
| font = small = ImageFont.load_default() |
| d.text((28, 22), title, font=font, fill=(255, 200, 110)) |
| d.text((30, 60), path.rsplit("/", 1)[-1], font=small, fill=(170, 140, 110)) |
| img.save(out, optimize=True) |
|
|
|
|
| if __name__ == "__main__": |
| render(sys.argv[1], sys.argv[2], sys.argv[3] if len(sys.argv) > 3 else "") |
|
|
