```python
import bpy
import math
import random

# ==========================================
# 1. SETUP ENGINE & SCENE CLEANUP
# ==========================================
def setup_engine():
    # Set Cycles render engine
    bpy.context.scene.render.engine = 'CYCLES'
    bpy.context.scene.cycles.samples = 64
    bpy.context.scene.cycles.use_denoising = True

    # Color management for nice atmospheric film look
    bpy.context.scene.view_settings.view_transform = 'AgX'
    bpy.context.scene.view_settings.look = 'Punchy'

    # Clean default objects
    if "Cube" in bpy.data.objects:
        bpy.data.objects.remove(bpy.data.objects["Cube"], do_unlink=True)
    if "Light" in bpy.data.objects:
        bpy.data.objects.remove(bpy.data.objects["Light"], do_unlink=True)
    if "Camera" in bpy.data.objects:
        bpy.data.objects.remove(bpy.data.objects["Camera"], do_unlink=True)

setup_engine()

# ==========================================
# 2. MATERIAL CREATION (Procedural / PBR)
# ==========================================
def create_materials():
    mats = {}

    # --- 1. Weathered Stone ---
    stone = bpy.data.materials.new(name="StoneMaterial")
    stone.use_nodes = True
    s_nodes = stone.node_tree.nodes
    s_links = stone.node_tree.links
    s_bsdf = s_nodes.get("Principled BSDF")
    s_bsdf.inputs['Roughness'].default_value = 0.85

    # Noise for weathered map
    s_noise = s_nodes.new('ShaderNodeTexNoise')
    s_noise.inputs['Scale'].default_value = 6.0
    s_noise.inputs['Detail'].default_value = 8.0

    s_bump = s_nodes.new('ShaderNodeBump')
    s_bump.inputs['Strength'].default_value = 0.4
    s_links.new(s_noise.outputs['Fac'], s_bump.inputs['Height'])
    s_links.new(s_bump.outputs['Normal'], s_bsdf.inputs['Normal'])

    s_mix = s_nodes.new('ShaderNodeMix')
    s_mix.data_type = 'RGBA'
    s_mix.blend_type = 'MIX'
    s_mix.inputs[1].default_value = (0.55, 0.52, 0.48, 1.0)  # Antique warm stone
    s_mix.inputs[2].default_value = (0.35, 0.38, 0.35, 1.0)  # Mossy weathered accent
    s_links.new(s_noise.outputs['Fac'], s_mix.inputs['Factor'])
    s_links.new(s_mix.outputs['Result'], s_bsdf.inputs['Base Color'])
    mats['stone'] = stone

    # --- 2. Vibrant Foliage (Luminous Greenery) ---
    foliage = bpy.data.materials.new(name="FoliageMaterial")
    foliage.use_nodes = True
    f_nodes = foliage.node_tree.nodes
    f_links = foliage.node_tree.links
    f_bsdf = f_nodes.get("Principled BSDF")
    f_bsdf.inputs['Subsurface Weight'].default_value = 0.35
    f_bsdf.inputs['Roughness'].default_value = 0.6

    f_noise = f_nodes.new('ShaderNodeTexNoise')
    f_noise.inputs['Scale'].default_value = 12.0

    f_mix = f_nodes.new('ShaderNodeMix')
    f_mix.data_type = 'RGBA'
    f_mix.blend_type = 'MIX'
    f_mix.inputs[1].default_value = (0.2, 0.45, 0.12, 1.0)  # Deep emerald
    f_mix.inputs[2].default_value = (0.55, 0.75, 0.15, 1.0)  # Sunny yellow-green
    f_links.new(f_noise.outputs['Fac'], f_mix.inputs['Factor'])
    f_links.new(f_mix.outputs['Result'], f_bsdf.inputs['Base Color'])
    mats['foliage'] = foliage

    # --- 3. Rusted Iron ---
    iron = bpy.data.materials.new(name="RustedIronMaterial")
    iron.use_nodes = True
    i_nodes = iron.node_tree.nodes
    i_links = iron.node_tree.links
    i_bsdf = i_nodes.get("Principled BSDF")
    i_bsdf.inputs['Metallic'].default_value = 0.8
    i_bsdf.inputs['Roughness'].default_value = 0.55

    i_noise = i_nodes.new('ShaderNodeTexNoise')
    i_noise.inputs['Scale'].default_value = 15.0

    i_mix = i_nodes.new('ShaderNodeMix')
    i_mix.data_type = 'RGBA'
    i_mix.blend_type = 'MIX'
    i_mix.inputs[1].default_value = (0.15, 0.15, 0.16, 1.0)  # Old iron
    i_mix.inputs[2].default_value = (0.45, 0.22, 0.12, 1.0)  # Deep rust
    i_links.new(i_noise.outputs['Fac'], i_mix.inputs['Factor'])
    i_links.new(i_mix.outputs['Result'], i_bsdf.inputs['Base Color'])
    mats['iron'] = iron

    # --- 4. Wood Sleeps ---
    wood = bpy.data.materials.new(name="WoodSleepersMaterial")
    wood.use_nodes = True
    w_nodes = wood.node_tree.nodes
    w_bsdf = w_nodes.get("Principled BSDF")
    w_bsdf.inputs['Base Color'].default_value = (0.22, 0.16, 0.12, 1.0)
    w_bsdf.inputs['Roughness'].default_value = 0.9
    mats['wood'] = wood

    # --- 5. Clock Face ---
    clock_face = bpy.data.materials.new(name="ClockFaceMaterial")
    clock_face.use_nodes = True
    c_nodes = clock_face.node_tree.nodes
    c_bsdf = c_nodes.get("Principled BSDF")
    c_bsdf.inputs['Base Color'].default_value = (0.92, 0.90, 0.85, 1.0)  # Aged Ivory
    c_bsdf.inputs['Roughness'].default_value = 0.3
    mats['clock_face'] = clock_face

    # --- 6. Glass (Shattered / Dirty) ---
    glass = bpy.data.materials.new(name="DirtyGlassMaterial")
    glass.use_nodes = True
    g_nodes = glass.node_tree.nodes
    g_bsdf = g_nodes.get("Principled BSDF")
    g_bsdf.inputs['Transmission Weight'].default_value = 0.9
    g_bsdf.inputs['Roughness'].default_value = 0.35
    g_bsdf.inputs['Base Color'].default_value = (0.85, 0.92, 0.90, 1.0)
    mats['glass'] = glass

    # --- 7. Rain Puddles (High reflection) ---
    puddle = bpy.data.materials.new(name="PuddleMaterial")
    puddle.use_nodes = True
    p_nodes = puddle.node_tree.nodes
    p_bsdf = p_nodes.get("Principled BSDF")
    p_bsdf.inputs['Base Color'].default_value = (0.05, 0.06, 0.05, 1.0)
    p_bsdf.inputs['Roughness'].default_value = 0.02
    p_bsdf.inputs['Specular IOR Level'].default_value = 0.8
    mats['puddle'] = puddle

    # --- 8. Glowing Emissives ---
    # Amber CRT
    g_amber = bpy.data.materials.new(name="AmberCRT")
    g_amber.use_nodes = True
    ga_bsdf = g_amber.node_tree.nodes.get("Principled BSDF")
    ga_bsdf.inputs['Emission Color'].default_value = (1.0, 0.45, 0.02, 1.0)
    ga_bsdf.inputs['Emission Strength'].default_value = 15.0
    mats['glow_amber'] = g_amber

    # Green Phosphor
    g_green = bpy.data.materials.new(name="GreenPhosphor")
    g_green.use_nodes = True
    gg_bsdf = g_green.node_tree.nodes.get("Principled BSDF")
    gg_bsdf.inputs['Emission Color'].default_value = (0.05, 1.0, 0.25, 1.0)
    gg_bsdf.inputs['Emission Strength'].default_value = 18.0
    mats['glow_green'] = g_green

    # Red Signal
    g_red = bpy.data.materials.new(name="RedSignal")
    g_red.use_nodes = True
    gr_bsdf = g_red.node_tree.nodes.get("Principled BSDF")
    gr_bsdf.inputs['Emission Color'].default_value = (1.0, 0.01, 0.01, 1.0)
    gr_bsdf.inputs['Emission Strength'].default_value = 35.0
    mats['glow_red'] = g_red

    # Gold Wordmark
    gold = bpy.data.materials.new(name="GoldWordmark")
    gold.use_nodes = True
    go_bsdf = gold.node_tree.nodes.get("Principled BSDF")
    go_bsdf.inputs['Base Color'].default_value = (0.85, 0.65, 0.22, 1.0)
    go_bsdf.inputs['Metallic'].default_value = 0.95
    go_bsdf.inputs['Roughness'].default_value = 0.25
    mats['gold'] = gold

    return mats

mats = create_materials()

# ==========================================
# 3. GEOMETRY UTILITIES
# ==========================================
def add_cube(name, loc, scale, mat=None, rot=(0,0,0)):
    bpy.ops.mesh.primitive_cube_add(location=loc, scale=scale, rotation=rot)
    obj = bpy.context.active_object
    obj.name = name
    if mat:
        obj.data.materials.append(mat)
    return obj

def add_cylinder(name, loc, radius, depth, mat=None, rot=(0,0,0)):
    bpy.ops.mesh.primitive_cylinder_add(location=loc, radius=radius, depth=depth, rotation=rot)
    obj = bpy.context.active_object
    obj.name = name
    if mat:
        obj.data.materials.append(mat)
    return obj

# ==========================================
# 4. SCENE RECONSTRUCTION
# ==========================================

# --- A. Sunken Cutting Bed & Platform Level ---
# Ground floor at Z = -4.0 (where tracks sit)
add_cube("Cutting_Bed", (1.5, 0.0, -4.15), (7.0, 25.0, 0.1), mats['stone'])

# High platform level at Z = 0.0 (left side)
add_cube("Concourse_Platform", (-6.5, 0.0, -0.05), (3.0, 25.0, 0.05), mats['stone'])

# Massive stone retaining walls flanking the cutting
add_cube("RetainingWall_Left", (-3.5, 0.0, -2.0), (0.2, 25.0, 2.0), mats['stone'])
add_cube("RetainingWall_Right", (6.5, 0.0, -1.0), (0.2, 25.0, 3.0), mats['stone'])

# Add rhythmic grand arches along retaining wall right to feel monumental
for i in range(-5, 6):
    add_cube(f"Wall_Buttress_{i}", (6.3, i * 4.0, -1.0), (0.25, 0.6, 3.0), mats['stone'])

# --- B. Parallel Railway Tracks ---
# Left Train Track (X = -1.0) & Right Train Track (X = 3.5)
for tx in [-1.0, 3.5]:
    # Sleepers (Wooden ties)
    for y in range(-24, 25, 2):
        add_cube(f"Sleeper_{tx}_{y}", (tx, y, -4.05), (1.1, 0.22, 0.1), mats['wood'])
    # Steel Rails
    add_cube(f"Rail_{tx}_L", (tx - 0.45, 0.0, -3.95), (0.05, 25.0, 0.05), mats['iron'])
    add_cube(f"Rail_{tx}_R", (tx + 0.45, 0.0, -3.95), (0.05, 25.0, 0.05), mats['iron'])

# --- C. Broad Elegant Stone Stairs ---
# Descending from Platform (Z=0, X=-3.5) to Tracks (Z=-4.0)
for step in range(12):
    sz = -0.33 * step
    sy = -5.0 + (step * 0.45)
    add_cube(f"StairStep_{step}", (-2.2, sy, sz), (1.1, 0.25, 0.18), mats['stone'])

# --- D. Platform Railings ---
# Iron railings along the edge of the descent cutting
add_cube("Platform_Rail_Base", (-3.5, 0.0, 0.05), (0.05, 25.0, 0.05), mats['stone'])
# Generate elegant baluster railing posts
for p_y in range(-22, 23, 2):
    add_cylinder(f"RailPost_{p_y}", (-3.5, p_y + 0.5, 0.65), 0.025, 1.2, mats['iron'])
# Handrail top
add_cube("Handrail_Top", (-3.5, 0.0, 1.25), (0.03, 25.0, 0.03), mats['iron'])

# --- E. Clock Tower (Dominant Vertical Element) ---
# Monumental tower sitting at X = -7.5, Y = 6.0, rises from Z = 0 to Z = 18
add_cube("ClockTower_Base", (-7.5, 6.0, 6.0), (1.8, 1.8, 6.0), mats['stone'])
add_cube("ClockTower_Mid", (-7.5, 6.0, 13.5), (1.65, 1.65, 1.5), mats['stone'])
add_cube("ClockTower_Trim", (-7.5, 6.0, 14.5), (1.9, 1.9, 0.25), mats['stone'])

# Gothic pyramid roof peak
bpy.ops.mesh.primitive_cone_add(vertices=4, radius1=2.1, depth=3.5, location=(-7.5, 6.0, 16.5))
ct_roof = bpy.context.active_object
ct_roof.name = "ClockTower_Roof"
ct_roof.data.materials.append(mats['stone'])

# The pale vintage Clock Face (facing south-west, rotated slightly)
# We place it on the negative-Y facing side, oriented out beautifully at Y = 4.15, Z = 13.5
add_cylinder("Clock_Dial", (-7.5, 4.15, 13.5), 1.1, 0.08, mats['clock_face'], rot=(1.5708, 0, 0))
# Black hands
add_cube("Clock_HourHand", (-7.5, 4.08, 13.5), (0.04, 0.02, 0.45), mats['iron'], rot=(0, -0.65, 0))
add_cube("Clock_MinHand", (-7.5, 4.08, 13.5), (0.03, 0.02, 0.8), mats['iron'], rot=(0, 0.85, 0))

# --- F. Grand Booking Hall Facade & Arches ---
# Wall structure situated on platform
add_cube("BookingHall_Wall1", (-9.5, 0.0, 4.0), (0.4, 15.0, 4.0), mats['stone'])
# Massive Arch windows spanning the facade
for w_y in [-8.0, -3.0, 2.0, 10.0]:
    add_cube(f"ArchFrame_{w_y}", (-9.1, w_y, 4.0), (0.1, 1.6, 2.8), mats['iron'])
    add_cube(f"ArchGlass_{w_y}", (-9.1, w_y, 4.0), (0.02, 1.5, 2.7), mats['glass'])

# --- G. Ruins of Canopy Iron Roof Trusses ---
# Arching system crossing over the sunken cutting
for truss_y in range(-12, 18, 6):
    # Support pillars on platform
    add_cylinder(f"CanopyPillar_{truss_y}", (-3.5, truss_y, 2.5), 0.12, 5.0, mats['iron'])
    # Horizontal spanning beam
    add_cube(f"Truss_Beam_{truss_y}", (1.5, truss_y, 5.0), (5.0, 0.08, 0.08), mats['iron'])
    # Angled gables mimicking classic Victorian iron roofs
    add_cube(f"Truss_AngleL_{truss_y}", (-1.0, truss_y, 6.2), (2.8, 0.06, 0.06), mats['iron'], rot=(0.0, -0.45, 0.0))
    add_cube(f"Truss_AngleR_{truss_y}", (4.0, truss_y, 6.2), (2.8, 0.06, 0.06), mats['iron'], rot=(0.0, 0.45, 0.0))
    # Intermittent broken glass panels
    if truss_y in [-12, 0, 12]:
        add_cube(f"BrokenCanopyGlass_1_{truss_y}", (-1.0, truss_y + 1.0, 6.3), (2.5, 1.0, 0.01), mats['glass'], rot=(0.0, -0.45, 0.0))
        add_cube(f"BrokenCanopyGlass_2_{truss_y}", (4.0, truss_y - 1.0, 6.3), (2.5, 1.0, 0.01), mats['glass'], rot=(0.0, 0.45, 0.0))

# --- H. Rain Puddles & Reflections ---
# Puddle on platform
add_cube("Puddle_Platform_1", (-5.6, -2.0, 0.01), (1.4, 4.5, 0.005), mats['puddle'])
# Puddles down inside track clearing in cutting
add_cube("Puddle_Track_1", (1.2, 5.0, -3.98), (1.5, 6.0, 0.005), mats['puddle'])

# --- I. Operational Anomalies (The Easter Eggs) ---
# 1. Amber-phosphor CRT Terminal glowing inside booking hall window nook
add_cube("CRT_Body", (-8.8, -3.0, 1.8), (0.35, 0.35, 0.35), mats['iron'])
add_cube("CRT_Screen", (-8.42, -3.0, 1.8), (0.05, 0.22, 0.22), mats['glow_amber'])

# 2. Large modern-classic Split-Flap Departures Board hanging high under canopy
add_cube("Departures_Frame", (-1.2, -4.5, 4.6), (0.1, 1.8, 0.75), mats['iron'])
add_cube("Dep_Text_Glow_Line1", (-1.08, -4.5, 4.8), (0.02, 1.6, 0.1), mats['glow_green'])
add_cube("Dep_Text_Glow_Line2", (-1.08, -4.5, 4.45), (0.02, 1.6, 0.1), mats['glow_green'])

# 3. Phosphor-green lamp beside a heavy staff door on station wall
# Door
add_cube("Staff_Door", (-9.1, 5.0, 1.6), (0.05, 1.1, 1.6), mats['wood'])
# Wall lantern casing + glowing element
add_cube("Staff_Lamp_Housing", (-8.8, 6.0, 2.5), (0.1, 0.1, 0.2), mats['iron'])
add_cylinder("Staff_Lamp_Glow", (-8.7, 6.0, 2.5), 0.06, 0.12, mats['glow_green'])

# 4. Single rich Red Railway Signal burning far down the lower cutting track
# Support column
add_cylinder("Signal_Post", (3.5, 23.0, -1.5), 0.08, 4.8, mats['iron'])
add_cube("Signal_Box", (3.5, 23.0, 1.1), 0.24, mats['iron'])
add_cylinder("Signal_RedLight", (3.5, 22.75, 1.1), 0.15, 0.1, mats['glow_red'], rot=(1.5708, 0, 0))

# --- J. Heritage Sign / Wordmark ---
# Plaque with "RAVENSTHWAITE & DISTRICT RAILWAY Co."
# Create backing plate first
add_cube("Sign_Plinth", (-7.5, -4.5, 3.4), (0.1, 2.8, 0.7), mats['stone'], rot=(0, 0, 0.12))

# Use 3D Text geometry for highly readable typography
bpy.ops.object.text_add(location=(-7.35, -7.0, 3.12), rotation=(1.5708, 0.0, 1.69), scale=(1, 1, 1))
txt_obj = bpy.context.active_object
txt_obj.name = "Heritage_Text"
txt_obj.data.body = "RAVENSTHWAITE &\nDISTRICT RAILWAY Co."
txt_obj.data.size = 0.28
txt_obj.data.extrude = 0.05
txt_obj.data.materials.append(mats['gold'])

# ==========================================
# 5. PROCEDURAL OVERGROWTH & ENVIRONMENT
# ==========================================
# Function to scatter leaf clumps at specific location spheres
def seed_vegetation_canopy(name, center_loc, bounds_scale, num_leaves):
    # Anchor point empty
    bpy.ops.object.empty_add(type='PLAIN_AXES', location=center_loc)
    canopy_parent = bpy.context.active_object
    canopy_parent.name = f"Canopy_{name}"

    # Generate randomized planes using high-translucency yellow-emerald foliage material
    for i in range(num_leaves):
        rx = random.uniform(-bounds_scale[0], bounds_scale[0])
        ry = random.uniform(-bounds_scale[1], bounds_scale[1])
        rz = random.uniform(-bounds_scale[2], bounds_scale[2])

        rot_x = random.uniform(0.0, 3.14)
        rot_y = random.uniform(0.0, 3.14)
        rot_z = random.uniform(0.0, 3.14)

        sc_val = random.uniform(0.18, 0.44)

        bpy.ops.mesh.primitive_plane_add(
            location=(center_loc[0] + rx, center_loc[1] + ry, center_loc[2] + rz),
            rotation=(rot_x, rot_y, rot_z),
            scale=(sc_val, sc_val, sc_val)
        )
        leaf = bpy.context.active_object
        leaf.name = f"Leaf_{name}_{i}"
        leaf.data.materials.append(mats['foliage'])
        leaf.parent = canopy_parent

# Placing rich greenery clusters throughout the entire scene to feel reclaimed:
# Climbing ivy clusters on the Clock Tower
seed_vegetation_canopy("Tower_Ivy_Base", (-7.5, 6.0, 1.5), (2.2, 2.2, 1.8), 45)
seed_vegetation_canopy("Tower_Ivy_Mid", (-7.4, 5.0, 8.5), (1.5, 1.5, 2.5), 35)

# Growing out of the tracks/Sleepers
seed_vegetation_canopy("Track_Flora_1", (-1.0, -1.0, -3.8), (0.8, 3.5, 0.3), 30)
seed_vegetation_canopy("Track_Flora_2", (3.5, 5.0, -3.8), (0.8, 4.0, 0.3), 35)
seed_vegetation_canopy("Track_Flora_Far", (2.0, 16.0, -3.8), (1.5, 5.0, 0.4), 45)

# Cascading from the grand staircase and platform edge
seed_vegetation_canopy("Staircase_Ivy", (-2.2, -2.5, -2.0), (0.6, 2.2, 1.2), 35)
seed_vegetation_canopy("Platform_Overgrowth", (-5.5, -12.0, 0.2), (1.5, 4.0, 0.3), 40)

# Overhanging colossal tree canopy on the top right
# We construct a weathered trunk
add_cylinder("Tree_Trunk_1", (7.0, -1.0, 1.5), 0.4, 7.0, mats['wood'])
# Giant lush foliage canopy hanging over tracks/canopy and filtering sunlight
seed_vegetation_canopy("HugeTree_Canopy", (5.8, -2.0, 6.5), (3.0, 4.5, 2.2), 110)

# Another background tree behind the clock tower
add_cylinder("Tree_Trunk_2", (-10.5, 12.0, 4.0), 0.5, 10.0, mats['wood'])
seed_vegetation_canopy("TowerBack_Canopy", (-9.5, 11.5, 11.5), (3.5, 3.5, 2.5), 90)

# ==========================================
# 6. CAMERA SETUP, COMPOSITION, LIGHTING
# ==========================================
def create_camera_and_lights():
    # Cinematic warm afternoon Sun
    sun_data = bpy.data.lights.new(name="GrandSun", type='SUN')
    sun_data.energy = 5.5
    sun_data.color = (1.0, 0.94, 0.86)  # Warm, rich summer daylight
    sun_data.angle = 0.5  # Soft shadow diffusion
    sun_obj = bpy.data.objects.new(name="GrandSun", object_data=sun_data)
    bpy.context.collection.objects.link(sun_obj)
    # Angle sun to penetrate the broken roof trusses downwards towards the tracks
    sun_obj.rotation_euler = (0.75, 0.25, -0.6)

    # Ambient Sky & World Light
    world = bpy.context.scene.world
    world.use_nodes = True
    bg_node = world.node_tree.nodes.get("Background")
    # Vibrant high-altitude blue sky
    bg_node.inputs['Color'].default_value = (0.42, 0.65, 0.88, 1.0)
    bg_node.inputs['Strength'].default_value = 1.3

    # Majestic Luminous Volumetric Fog (Mist) to catch sun shafts
    # Coordinates mapping entire station frame bounds
    bpy.ops.mesh.primitive_cube_add(location=(-1.0, 0.0, 4.0), scale=(12.0, 25.0, 10.0))
    mist_volume = bpy.context.active_object
    mist_volume.name = "VolumeAtmosphere"

    # Create volume emission & absorption shader
    vol_mat = bpy.data.materials.new(name="VolumeMaterial")
    vol_mat.use_nodes = True
    v_nodes = vol_mat.node_tree.nodes
    # Clear default
    for n in v_nodes:
        v_nodes.remove(n)
    v_out = v_nodes.new('ShaderNodeOutputMaterial')
    v_principled = v_nodes.new('ShaderNodeVolumePrincipled')
    v_principled.inputs['Density'].default_value = 0.038
    v_principled.inputs['Color'].default_value = (0.9, 0.95, 0.98, 1.0)
    # High anisotropy for spectacular forward scattering / light shafts
    v_principled.inputs['Anisotropy'].default_value = 0.75

    vol_mat.node_tree.links.new(v_principled.outputs['Volume'], v_out.inputs['Volume'])
    mist_volume.data.materials.append(vol_mat)

    # --- Focal Point Camera Composition ---
    # Placed on high concourse looking down towards the tracks and up towards the iconic Clock Tower
    cam_data = bpy.data.cameras.new(name="MainVantageCamera")
    cam_data.lens = 20  # Grand wide-angle to capture vertical and horizontal scale
    cam_obj = bpy.data.objects.new(name="MainVantageCamera", object_data=cam_data)
    bpy.context.collection.objects.link(cam_obj)

    # Positioned perfectly to capture the descent tracks, clocktower, and heritage sign in frame
    cam_obj.location = (-9.5, -15.5, 4.2)
    cam_obj.rotation_euler = (1.28, 0.0, 0.44) # Angled beautifully targeting tracking cut

    # Active camera setup
    bpy.context.scene.camera = cam_obj

create_camera_and_lights()

# Save complete file (Benchmark engine captures render preset)
print("Grand Victorian terminus landscape reconstruction complete.")
```