build: baked lighting pass on kit_demo test map

- Restructured kit_demo.tscn from linear demo to enclosed 5.12x5.12 room
  with walls, floor tiles, pillar, beam, doorway, window
- Added WorldEnvironment with ProceduralSky for ambient lighting
- Added DirectionalLight3D (sun key light, 45° angle, shadows enabled)
- Added OmniLight3D (warm interior fill light)
- Added ReflectionProbe for interior specular reflections
  (box projection, room-sized extents)
- Added LightmapGI with balanced quality settings
  (bounces=3, texel_scale=1.0, max_texture_size=2048, denoiser=true)
- Added tool script (kit_demo.gd) that prints bake status in editor
- Added bake_lighting.gd CLI bake script (requires GPU-enabled instance)
- Updated project.godot with reflection atlas and shadow map quality settings

Headless baking note: Godot's standard editor build requires a GPU/display
for LightmapGI.bake(). Open the scene in the Godot editor and click 'Bake
Lightmap' on the LightmapGI node to generate the baked lightmap data.

client/assets/textures/generate_textures.py

@@ -0,0 +1,493 @@
+#!/usr/bin/env python3
+"""
+Generate procedural 1K PBR texture maps for the Tactical Shooter modular art kit.
+Produces: basecolor, normal, roughness, metallic — all at 1024x1024.
+Usage: python3 generate_textures.py
+"""
+
+import math
+import os
+import random
+from PIL import Image, ImageFilter, ImageChops, ImageDraw
+
+TEXTURE_DIR = os.path.expanduser("/home/oplabs/tactical-shooter/client/assets/textures")
+SIZE = 1024
+
+random.seed(42)
+
+def save_pbr(base_dir, name, basecolor, normal, roughness, metallic):
+    """Save all PBR maps for one material."""
+    d = os.path.join(base_dir, name)
+    os.makedirs(d, exist_ok=True)
+    basecolor.save(os.path.join(d, "basecolor.png"))
+    normal.save(os.path.join(d, "normal.png"))
+    roughness.save(os.path.join(d, "roughness.png"))
+    metallic.save(os.path.join(d, "metallic.png"))
+    print(f"  Generated {name}/ — 4 maps saved")
+
+
+# ── Utility helpers ──────────────────────────────────────────────────────
+
+def gaussian_noise(size, scale=1.0, seed=None):
+    """Generate a grayscale image with gaussian noise."""
+    if seed is not None:
+        random.seed(seed)
+    img = Image.new("L", (size, size))
+    pix = img.load()
+    for y in range(size):
+        for x in range(size):
+            v = int(random.gauss(128, 64 * scale))
+            pix[x, y] = max(0, min(255, v))
+    return img
+
+
+def tile_blur(img, radius):
+    """Blur with tileable boundary by mirroring edges before blur."""
+    w, h = img.size
+    big = Image.new(img.mode, (w * 3, h * 3))
+    for dx in range(3):
+        for dy in range(3):
+            if dx == 1 and dy == 1:
+                big.paste(img, (w, h))
+            else:
+                # Mirror the tile
+                mirror = img.transpose(Image.FLIP_LEFT_RIGHT) if dx % 2 == 0 else img
+                if dy % 2 == 0:
+                    mirror = mirror.transpose(Image.FLIP_TOP_BOTTOM)
+                big.paste(mirror, (w * dx, h * dy))
+    big = big.filter(ImageFilter.GaussianBlur(radius))
+    return big.crop((w, h, w * 2, h * 2))
+
+
+def normal_from_height(height_img, strength=2.0):
+    """Generate an RGB normal map from a grayscale height map using Sobel."""
+    w, h = height_img.size
+    # Get pixel data
+    hpix = height_img.load()
+    normal = Image.new("RGB", (w, h))
+    npix = normal.load()
+    for y in range(h):
+        for x in range(w):
+            # Sample height with wrapping for tileability
+            sx1 = hpix[(x - 1) % w, y]
+            sx2 = hpix[(x + 1) % w, y]
+            sy1 = hpix[x, (y - 1) % h]
+            sy2 = hpix[x, (y + 1) % h]
+            dx = (sx2 - sx1) / 255.0
+            dy = (sy2 - sy1) / 255.0
+            dz = 1.0 / strength
+            length = math.sqrt(dx * dx + dy * dy + dz * dz)
+            nx = dx / length
+            ny = dy / length
+            nz = dz / length
+            # Map from [-1,1] to [0,255]
+            npix[x, y] = (
+                int((nx * 0.5 + 0.5) * 255),
+                int((ny * 0.5 + 0.5) * 255),
+                int((nz * 0.5 + 0.5) * 255),
+            )
+    return normal
+
+
+def make_cellular(size, cell_size=32, seed=None):
+    """Generate a cellular/Voronoi-like pattern as grayscale."""
+    if seed is not None:
+        random.seed(seed)
+    img = Image.new("L", (size, size))
+    pix = img.load()
+
+    # Generate cell centers with random heights
+    cells = {}
+    for cx in range(0, size + cell_size, cell_size):
+        for cy in range(0, size + cell_size, cell_size):
+            ox = random.randint(0, cell_size - 1)
+            oy = random.randint(0, cell_size - 1)
+            h = random.randint(40, 200)
+            cells[(cx + ox, cy + oy)] = h
+
+    for y in range(size):
+        for x in range(size):
+            min_dist = float("inf")
+            best_h = 128
+            for (cx, cy), h in cells.items():
+                d = (cx - x) ** 2 + (cy - y) ** 2
+                if d < min_dist:
+                    min_dist = d
+                    best_h = h
+            pix[x, y] = best_h
+    return img
+
+
+def concrete_base(size, base_rgb=(180, 175, 168), noise_scale=1.0):
+    """Generate concrete-like basecolor with aggregate variation."""
+    # Start with light noise
+    noise = gaussian_noise(size, scale=0.15, seed=42)
+    noise = tile_blur(noise, 4)
+    
+    # Add larger variation
+    big = gaussian_noise(size, scale=0.08, seed=43)
+    big = tile_blur(big, 24)
+    
+    # Add some darker speckles (aggregate)
+    speckle = Image.new("L", (size, size), 0)
+    spix = speckle.load()
+    for _ in range(800):
+        x = random.randint(0, size - 1)
+        y = random.randint(0, size - 1)
+        spix[x, y] = random.randint(30, 80)
+    speckle = tile_blur(speckle, 1.5)
+    
+    # Combine
+    combined = Image.new("L", (size, size))
+    cpix = combined.load()
+    npix = noise.load()
+    bpix = big.load()
+    skpix = speckle.load()
+    for y in range(size):
+        for x in range(size):
+            v = npix[x, y] + bpix[x, y] - 128 + skpix[x, y] - 30
+            cpix[x, y] = max(0, min(255, v))
+    
+    # Tint and apply
+    result = Image.new("RGB", (size, size))
+    rpix = result.load()
+    cp = combined.load()
+    for y in range(size):
+        for x in range(size):
+            f = cp[x, y] / 255.0
+            rpix[x, y] = (
+                max(0, min(255, int(base_rgb[0] * f / 180))),
+                max(0, min(255, int(base_rgb[1] * f / 175))),
+                max(0, min(255, int(base_rgb[2] * f / 168))),
+            )
+    return result
+
+
+# ── Material definitions ─────────────────────────────────────────────────
+
+def generate_wall_concrete_01():
+    """Light clean concrete — primary wall material."""
+    size = SIZE
+    # Basecolor
+    bc = concrete_base(size, base_rgb=(200, 195, 185))
+    bc = bc.filter(ImageFilter.SMOOTH)
+    
+    # Height map for normal (slight texture)
+    height = gaussian_noise(size, scale=0.1, seed=100)
+    height = tile_blur(height, 3)
+    normal = normal_from_height(height, strength=1.5)
+    
+    # Roughness — concrete is fairly rough
+    rough = gaussian_noise(size, scale=0.08, seed=200)
+    rough = tile_blur(rough, 6)
+    # Brighten a bit (rougher = lighter in roughness map)
+    rpix = rough.load()
+    for y in range(size):
+        for x in range(size):
+            rpix[x, y] = min(255, rpix[x, y] + 40)
+    
+    # Metallic — none
+    metallic = Image.new("L", (size, size), 0)
+    
+    save_pbr(TEXTURE_DIR, "wall_concrete_01", bc, normal, rough, metallic)
+
+
+def generate_wall_concrete_02():
+    """Darker, smoother concrete — accent walls."""
+    size = SIZE
+    bc = concrete_base(size, base_rgb=(145, 140, 135))
+    bc = bc.filter(ImageFilter.SMOOTH_MORE)
+    
+    height = gaussian_noise(size, scale=0.06, seed=101)
+    height = tile_blur(height, 5)
+    normal = normal_from_height(height, strength=1.2)
+    
+    rough = gaussian_noise(size, scale=0.06, seed=201)
+    rough = tile_blur(rough, 8)
+    rpix = rough.load()
+    for y in range(size):
+        for x in range(size):
+            rpix[x, y] = min(255, rpix[x, y] + 30)
+    
+    metallic = Image.new("L", (size, size), 0)
+    save_pbr(TEXTURE_DIR, "wall_concrete_02", bc, normal, rough, metallic)
+
+
+def generate_floor_tile_01():
+    """Checkerboard tile floor — interior spaces."""
+    size = SIZE
+    tile_size = 64  # 64px tiles at 1024 = 16 tiles across
+    
+    bc = Image.new("RGB", (size, size))
+    bpix = bc.load()
+    for y in range(size):
+        for x in range(size):
+            tx = x // tile_size
+            ty = y // tile_size
+            if (tx + ty) % 2 == 0:
+                # Light tile
+                v = 200 + random.randint(-10, 10)
+                bpix[x, y] = (v, v - 5, v - 10)
+            else:
+                # Dark tile
+                v = 160 + random.randint(-8, 8)
+                bpix[x, y] = (v, v - 3, v - 5)
+    
+    # Add grout lines
+    draw = ImageDraw.Draw(bc)
+    for i in range(0, size + 1, tile_size):
+        draw.line([(i, 0), (i, size)], fill=(70, 65, 60), width=2)
+        draw.line([(0, i), (size, i)], fill=(70, 65, 60), width=2)
+    
+    # Height map for normal
+    height = Image.new("L", (size, size), 128)
+    hpix = height.load()
+    for y in range(size):
+        for x in range(size):
+            tx = x // tile_size
+            ty = y // tile_size
+            gx = x % tile_size
+            gy = y % tile_size
+            # Slight bevel around edges (tile center higher)
+            d = min(gx, tile_size - gx, gy, tile_size - gy)
+            if d < 3:
+                hpix[x, y] = 100  # Grout is lower
+            else:
+                hpix[x, y] = 140 + (d % 4) * 5
+    
+    # Apply bevel and tile variation
+    hpix = height.load()
+    for y in range(size):
+        for x in range(size):
+            tx = x // tile_size
+            ty = y // tile_size
+            gx = x % tile_size
+            gy = y % tile_size
+            d_edge = min(gx, tile_size - gx, gy, tile_size - gy)
+            if d_edge < 2:
+                hpix[x, y] = 90
+            elif d_edge < 5:
+                hpix[x, y] = 100 + d_edge * 8
+            else:
+                # Gentle tile surface variation
+                hpix[x, y] = 140 + ((tx * 13 + ty * 7 + x + y) % 8) * 3
+    
+    normal = normal_from_height(height, strength=3.0)
+    
+    # Roughness — tiles are smooth
+    rough = Image.new("L", (size, size), 80)
+    rpix = rough.load()
+    for y in range(size):
+        for x in range(size):
+            tx = x // tile_size
+            ty = y // tile_size
+            gx = x % tile_size
+            gy = y % tile_size
+            d_edge = min(gx, tile_size - gx, gy, tile_size - gy)
+            if d_edge < 2:
+                rpix[x, y] = 200  # Grout is rough
+            else:
+                rpix[x, y] = 60 + ((tx * 17 + ty * 11) % 10) * 4
+    
+    metallic = Image.new("L", (size, size), 0)
+    save_pbr(TEXTURE_DIR, "floor_tile_01", bc, normal, rough, metallic)
+
+
+def generate_floor_concrete_01():
+    """Industrial dark concrete floor — warehouse/industrial areas."""
+    size = SIZE
+    
+    # Base
+    bc = concrete_base(size, base_rgb=(130, 128, 123))
+    bc = bc.filter(ImageFilter.SMOOTH)
+    
+    # Add surface scratches/wear marks
+    draw = ImageDraw.Draw(bc)
+    for _ in range(50):
+        x1 = random.randint(0, size)
+        y1 = random.randint(0, size)
+        length = random.randint(10, 100)
+        angle = random.uniform(0, math.pi * 2)
+        x2 = x1 + int(math.cos(angle) * length)
+        y2 = y1 + int(math.sin(angle) * length)
+        c = random.randint(100, 140)
+        draw.line([(x1, y1), (x2, y2)], fill=(c, c - 3, c - 5), width=1)
+    
+    height = gaussian_noise(size, scale=0.15, seed=102)
+    height = tile_blur(height, 3)
+    hpix = height.load()
+    # Add groove lines (expansion joints)
+    for y in range(size):
+        for x in range(size):
+            gx = x % 256
+            gy = y % 256
+            if min(gx, 256 - gx) < 2 or min(gy, 256 - gy) < 2:
+                hpix[x, y] = max(0, hpix[x, y] - 40)
+    normal = normal_from_height(height, strength=2.5)
+    
+    rough = Image.new("L", (size, size), 160)
+    rpix = rough.load()
+    for y in range(size):
+        for x in range(size):
+            gx = x % 256
+            gy = y % 256
+            if min(gx, 256 - gx) < 2 or min(gy, 256 - gy) < 2:
+                rpix[x, y] = 220  # Grooves are rougher
+            else:
+                rpix[x, y] = 150 + (hash((x // 8, y // 8)) % 20)
+    
+    metallic = Image.new("L", (size, size), 0)
+    save_pbr(TEXTURE_DIR, "floor_concrete_01", bc, normal, rough, metallic)
+
+
+def generate_metal_structural_01():
+    """Structural metal — beams, supports, vents."""
+    size = SIZE
+    # Base — grey metallic
+    bc = Image.new("RGB", (size, size))
+    bpix = bc.load()
+    for y in range(size):
+        for x in range(size):
+            v = 160 + int(random.gauss(0, 4))
+            bpix[x, y] = (max(0, min(255, v)), max(0, min(255, v - 2)), max(0, min(255, v - 4)))
+    
+    # Add horizontal brush marks
+    draw = ImageDraw.Draw(bc)
+    for _ in range(200):
+        bx = random.randint(0, size - 1)
+        by = random.randint(0, size - 1)
+        c = random.randint(-6, 6)
+        draw.line([(bx, by), (bx + random.randint(10, 60), by)], fill=(bpix[bx, by][0] + c,) * 3, width=1)
+    
+    # Height map for normal
+    height = gaussian_noise(size, scale=0.05, seed=103)
+    height = tile_blur(height, 2)
+    hpix = height.load()
+    for y in range(size):
+        for x in range(size):
+            hpix[x, y] = max(0, min(255, hpix[x, y] - 10))  # Flatter than concrete
+    normal = normal_from_height(height, strength=1.0)  # Subtle
+    
+    # Roughness — smooth metal
+    rough = Image.new("L", (size, size), 40)
+    rpix = rough.load()
+    for y in range(size):
+        for x in range(size):
+            hp = hpix[x, y]
+            rpix[x, y] = 30 + (hp - 128) // 8
+    
+    # Metallic — yes!
+    metallic = Image.new("L", (size, size), 255)
+    save_pbr(TEXTURE_DIR, "metal_structural_01", bc, normal, rough, metallic)
+
+
+def generate_accent_team_blue():
+    """Blue team accent — CT side colored panels."""
+    size = SIZE
+    # Deep blue
+    bc = Image.new("RGB", (size, size))
+    bpix = bc.load()
+    for y in range(size):
+        for x in range(size):
+            noise = random.randint(-8, 8)
+            bpix[x, y] = (
+                max(0, min(255, 40 + noise)),
+                max(0, min(255, 80 + noise)),
+                max(0, min(255, 200 + noise)),
+            )
+    bc = bc.filter(ImageFilter.SMOOTH)
+    # Slight brushed pattern
+    draw = ImageDraw.Draw(bc)
+    for y in range(0, size, 4):
+        v = random.randint(-4, 4)
+        draw.line([(0, y), (size, y)], fill=(40 + v, 80 + v, 200 + v), width=1)
+    
+    height = Image.new("L", (size, size), 128)
+    hpix = height.load()
+    for y in range(size):
+        for x in range(size):
+            hpix[x, y] = 128 + int(random.gauss(0, 3))
+    hpix = height.load()
+    for y in range(0, size, 4):
+        for x in range(size):
+            hpix[x, y] = 110  # Slight panel line
+    normal = normal_from_height(height, strength=0.8)
+    
+    rough = Image.new("L", (size, size), 50)
+    rpix = rough.load()
+    for y in range(size):
+        for x in range(size):
+            rpix[x, y] = 40 + (hash((x // 16, y // 16)) % 15)
+    
+    # Slightly metallic (painted metal)
+    metallic = Image.new("L", (size, size), 128)
+    save_pbr(TEXTURE_DIR, "accent_team_blue", bc, normal, rough, metallic)
+
+
+def generate_accent_team_red():
+    """Red/orange team accent — T side colored panels."""
+    size = SIZE
+    bc = Image.new("RGB", (size, size))
+    bpix = bc.load()
+    for y in range(size):
+        for x in range(size):
+            noise = random.randint(-8, 8)
+            bpix[x, y] = (
+                max(0, min(255, 200 + noise)),
+                max(0, min(255, 60 + noise)),
+                max(0, min(255, 30 + noise)),
+            )
+    bc = bc.filter(ImageFilter.SMOOTH)
+    draw = ImageDraw.Draw(bc)
+    for y in range(0, size, 4):
+        v = random.randint(-4, 4)
+        draw.line([(0, y), (size, y)], fill=(200 + v, 60 + v, 30 + v), width=1)
+    
+    height = Image.new("L", (size, size), 128)
+    hpix = height.load()
+    for y in range(size):
+        for x in range(size):
+            hpix[x, y] = 128 + int(random.gauss(0, 3))
+    for y in range(0, size, 4):
+        for x in range(size):
+            hpix[x, y] = 110
+    normal = normal_from_height(height, strength=0.8)
+    
+    rough = Image.new("L", (size, size), 50)
+    rpix = rough.load()
+    for y in range(size):
+        for x in range(size):
+            rpix[x, y] = 40 + (hash((x // 16, y // 16)) % 15)
+    
+    metallic = Image.new("L", (size, size), 128)
+    save_pbr(TEXTURE_DIR, "accent_team_red", bc, normal, rough, metallic)
+
+
+# ── Main ────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    os.makedirs(TEXTURE_DIR, exist_ok=True)
+    print("Generating PBR textures (1K)…")
+    
+    print("  [1/7] wall_concrete_01")
+    generate_wall_concrete_01()
+    
+    print("  [2/7] wall_concrete_02")
+    generate_wall_concrete_02()
+    
+    print("  [3/7] floor_tile_01")
+    generate_floor_tile_01()
+    
+    print("  [4/7] floor_concrete_01")
+    generate_floor_concrete_01()
+    
+    print("  [5/7] metal_structural_01")
+    generate_metal_structural_01()
+    
+    print("  [6/7] accent_team_blue")
+    generate_accent_team_blue()
+    
+    print("  [7/7] accent_team_red")
+    generate_accent_team_red()
+    
+    print("\nDone — 7 materials × 4 maps = 28 texture files generated at 1K.")