**Creating a scene generator** I'm thinking about providing a scene generator script to use in Blender 4.2+ with Cycles. I want to make it clear that this script creates a detailed procedural recreation rather than a survey-accurate replica. The scene will need to incorporate camera angles and surroundings while using procedural meshes to add architectural details like window glazing and rooftops. It’s essential to research the accurate dimensions of something like the Empire State Building to ensure the proportions are right. **Blender + Cycles** is the best fit for an editable architectural model with high-quality offline lighting and shadows. I can’t execute Blender or attach a finished `.blend` from this chat, but the script below **generates the model, sets up the lighting, saves the Blender project, and renders it**. ### What it creates - Empire State–style stepped massing, approximately **443.2 m to the antenna tip** - Thousands of recessed, individually framed windows - Procedural limestone, reflective glazing, metal spandrels, roof equipment, observation-deck railings, and a detailed crown - Golden-hour sky, physically sized sun, indirect lighting, and subtle atmospheric haze - Generic surrounding city blocks for reflections and context - **8K portrait rendering**, up to **4,096 Cycles samples**, denoising, and AgX color management - `.blend`, **16-bit PNG**, and **32-bit EXR** outputs **Accuracy note:** This is a detailed procedural interpretation, not a measured/BIM-accurate replica. The façade layout and surrounding city are approximate. ### Run it 1. Open **Blender 4.2 LTS** in a **new file**. 2. Go to **Scripting → New**, paste the script, and click **Run Script**. 3. Files are written to `Empire_State_Output` in your home folder. **The script replaces the current scene.** For a quick test, change `QUALITY = "FINAL"` to `"PREVIEW"` first. The final preset is intentionally demanding. ```python import bpy import math import random from pathlib import Path from mathutils import Vector # ============================================================ # CONFIGURATION # ============================================================ QUALITY = "FINAL" # "PREVIEW" or "FINAL" RENDER_NOW = True # False: build and save the .blend only ADD_CITY = True ADD_HAZE = True OUTPUT = Path.home() / "Empire_State_Output" OUTPUT.mkdir(parents=True, exist_ok=True) FINAL = QUALITY.upper() == "FINAL" RNG = random.Random(1931) CAMERA_POSITION = Vector((510.0, -680.0, 238.0)) # ============================================================ # CLEAN SCENE # ============================================================ for obj in list(bpy.data.objects): bpy.data.objects.remove(obj, do_unlink=True) for col in list(bpy.data.collections): bpy.data.collections.remove(col) for datablocks in ( bpy.data.meshes, bpy.data.curves, bpy.data.materials, bpy.data.lights, bpy.data.cameras ): for block in list(datablocks): if block.users == 0: datablocks.remove(block) scene = bpy.context.scene scene.unit_settings.system = "METRIC" scene.unit_settings.scale_length = 1.0 def collection(name): col = bpy.data.collections.new(name) scene.collection.children.link(col) return col HERO = collection("01 | Empire State Building") CITY = collection("02 | City Context") ENVIRONMENT = collection("03 | Environment") LIGHTING = collection("04 | Lighting") CAMERAS = collection("05 | Cameras") # ============================================================ # MATERIALS # ============================================================ def principled(name, color, roughness=0.5, metallic=0.0, transmission=0.0, emission=None): mat = bpy.data.materials.new(name) mat.use_nodes = True mat.diffuse_color = (*color, 1.0) bs = mat.node_tree.nodes.get("Principled BSDF") bs.inputs["Base Color"].default_value = (*color, 1.0) bs.inputs["Roughness"].default_value = roughness bs.inputs["Metallic"].default_value = metallic bs.inputs["Transmission Weight"].default_value = transmission bs.inputs["IOR"].default_value = 1.46 if emission: rgb, strength = emission bs.inputs["Emission Color"].default_value = (*rgb, 1.0) bs.inputs["Emission Strength"].default_value = strength return mat def textured_surface(name, low, high, roughness=0.7, macro_scale=0.25, micro_scale=80.0, bump_distance=0.008, metallic=0.0): mat = principled(name, low, roughness, metallic) nodes = mat.node_tree.nodes links = mat.node_tree.links bs = nodes.get("Principled BSDF") geo = nodes.new("ShaderNodeNewGeometry") macro = nodes.new("ShaderNodeTexNoise") macro.inputs["Scale"].default_value = macro_scale macro.inputs["Detail"].default_value = 4.0 macro.inputs["Roughness"].default_value = 0.7 ramp = nodes.new("ShaderNodeValToRGB") ramp.color_ramp.elements[0].position = 0.15 ramp.color_ramp.elements[0].color = (*low, 1.0) ramp.color_ramp.elements[1].position = 0.85 ramp.color_ramp.elements[1].color = (*high, 1.0) micro = nodes.new("ShaderNodeTexNoise") micro.inputs["Scale"].default_value = micro_scale micro.inputs["Detail"].default_value = 2.0 bump = nodes.new("ShaderNodeBump") bump.inputs["Strength"].default_value = 0.18 bump.inputs["Distance"].default_value = bump_distance links.new(geo.outputs["Position"], macro.inputs["Vector"]) links.new(macro.outputs["Fac"], ramp.inputs["Fac"]) links.new(ramp.outputs["Color"], bs.inputs["Base Color"]) links.new(geo.outputs["Position"], micro.inputs["Vector"]) links.new(micro.outputs["Fac"], bump.inputs["Height"]) links.new(bump.outputs["Normal"], bs.inputs["Normal"]) return mat M_STONE = textured_surface( "Limestone | subtle mineral variation", (0.43, 0.405, 0.35), (0.68, 0.64, 0.55), roughness=0.72 ) M_EDGE = principled( "Limestone | pale architectural trim", (0.64, 0.60, 0.52), 0.66 ) M_GLASS = principled( "Window glass | solid dielectric panes", (0.88, 0.95, 0.98), 0.055, transmission=1.0 ) M_FRAME = principled( "Window frames | dark nickel", (0.12, 0.145, 0.15), 0.29, 0.85 ) M_SPANDREL = textured_surface( "Spandrels | aged pewter", (0.19, 0.205, 0.19), (0.31, 0.325, 0.29), roughness=0.4, micro_scale=120.0, bump_distance=0.001, metallic=0.72 ) M_STEEL = principled( "Crown | brushed stainless steel", (0.61, 0.65, 0.69), 0.23, 0.95 ) M_INFILL = principled( "Crown | dark metal infill", (0.035, 0.052, 0.065), 0.25, 0.6 ) M_ANTENNA = principled( "Antenna | pale coated metal", (0.72, 0.74, 0.75), 0.3, 0.5 ) M_ROOF = textured_surface( "Roof | mineral membrane", (0.055, 0.063, 0.068), (0.13, 0.14, 0.14), roughness=0.9, macro_scale=0.8, micro_scale=32.0, bump_distance=0.023 ) M_DARK_ROOM = principled( "Interiors | unlit", (0.009, 0.014, 0.02), 0.9 ) M_WARM_ROOM = principled( "Interiors | warm occupied", (0.23, 0.13, 0.055), 0.85, emission=((1.0, 0.57, 0.25), 1.15) ) M_NEUTRAL_ROOM = principled( "Interiors | neutral occupied", (0.22, 0.21, 0.16), 0.85, emission=((1.0, 0.83, 0.60), 0.75) ) M_BLIND = principled( "Interiors | roller blinds", (0.28, 0.255, 0.20), 0.95 ) M_BRASS = principled( "Entrance | aged brass", (0.53, 0.35, 0.12), 0.28, 0.88 ) M_BEACON = principled( "Aviation lights", (0.4, 0.008, 0.003), 0.25, emission=((1.0, 0.015, 0.003), 8.0) ) M_ASPHALT = textured_surface( "Street | asphalt", (0.025, 0.029, 0.033), (0.07, 0.075, 0.08), roughness=0.94, macro_scale=0.6, micro_scale=95.0, bump_distance=0.006 ) M_PAVING = textured_surface( "Sidewalk | stone paving", (0.25, 0.26, 0.25), (0.39, 0.40, 0.38), roughness=0.85, micro_scale=55.0, bump_distance=0.004 ) M_PAINT = principled( "Road markings | weathered white", (0.56, 0.55, 0.48), 0.82 ) M_YELLOW = principled( "Road markings | yellow", (0.62, 0.37, 0.045), 0.75 ) # ============================================================ # BATCHED GEOMETRY # Batches avoid creating tens of thousands of separate objects. # ============================================================ BATCHES = [] UNIT_CUBE = ( (-1, -1, -1), (1, -1, -1), (1, 1, -1), (-1, 1, -1), (-1, -1, 1), (1, -1, 1), (1, 1, 1), (-1, 1, 1) ) CUBE_FACES = ( (0, 3, 2, 1), (4, 5, 6, 7), (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (3, 0, 4, 7) ) def octagon(width, depth): x, y = width / 2, depth / 2 c = min(width, depth) * 0.20 return [ Vector((-x + c, -y)), Vector((x - c, -y)), Vector((x, -y + c)), Vector((x, y - c)), Vector((x - c, y)), Vector((-x + c, y)), Vector((-x, y - c)), Vector((-x, -y + c)) ] class Batch: def __init__(self, name, material, target=HERO, bevel=0.0): self.name = name self.material = material self.target = target self.bevel = bevel self.vertices = [] self.faces = [] self.smooth = [] self.object = None BATCHES.append(self) def face(self, indices, smooth=False): self.faces.append(tuple(indices)) self.smooth.append(smooth) def box(self, center, size): if min(size) <= 0: return start = len(self.vertices) cx, cy, cz = center sx, sy, sz = size self.vertices.extend( (cx + x * sx / 2, cy + y * sy / 2, cz + z * sz / 2) for x, y, z in UNIT_CUBE ) for face in CUBE_FACES: self.face(start + k for k in face) def rod(self, start, end, radius, radius2=None, sides=16): p, q = Vector(start), Vector(end) direction = q - p if direction.length < 0.00001: return direction.normalize() radius2 = radius if radius2 is None else radius2 reference = ( Vector((0, 0, 1)) if abs(direction.z) < 0.9 else Vector((1, 0, 0)) ) u = direction.cross(reference).normalized() v = direction.cross(u).normalized() first = len(self.vertices) for center, r in ((p, radius), (q, radius2)): for k in range(sides): angle = math.tau * k / sides point = center + r * ( math.cos(angle) * u + math.sin(angle) * v ) self.vertices.append(tuple(point)) self.face(first + k for k in reversed(range(sides))) self.face(first + sides + k for k in range(sides)) for k in range(sides): nxt = (k + 1) % sides self.face(( first + k, first + nxt, first + sides + nxt, first + sides + k ), True) def octagonal(self, width, depth, z0, z1, top_width=None, top_depth=None): top_width = width if top_width is None else top_width top_depth = depth if top_depth is None else top_depth first = len(self.vertices) for ring, z in ( (octagon(width, depth), z0), (octagon(top_width, top_depth), z1) ): self.vertices.extend((p.x, p.y, z) for p in ring) self.face(first + k for k in reversed(range(8))) self.face(first + 8 + k for k in range(8)) for k in range(8): nxt = (k + 1) % 8 self.face(( first + k, first + nxt, first + 8 + nxt, first + 8 + k )) def finish(self): if not self.vertices: return None mesh = bpy.data.meshes.new(self.name) mesh.from_pydata(self.vertices, [], self.faces) mesh.update() mesh.polygons.foreach_set("use_smooth", self.smooth) obj = bpy.data.objects.new(self.name, mesh) self.target.objects.link(obj) obj.data.materials.append(self.material) if self.bevel: modifier = obj.modifiers.new("Micro edge highlights", "BEVEL") modifier.width = self.bevel modifier.segments = 3 if FINAL else 2 modifier.limit_method = "ANGLE" modifier.angle_limit = math.radians(32) modifier.use_clamp_overlap = True self.object = obj self.vertices.clear() self.faces.clear() self.smooth.clear() return obj stone = Batch("01 | Limestone facade", M_STONE, bevel=0.035) trim = Batch("02 | Projecting limestone details", M_EDGE, bevel=0.022) frames = Batch("03 | Window frames and mullions", M_FRAME, bevel=0.009) glass = Batch("04 | Recessed glass panes", M_GLASS) spandrels = Batch("05 | Metal spandrels", M_SPANDREL, bevel=0.01) dark_rooms = Batch("06 | Dark interior backing", M_DARK_ROOM) warm_rooms = Batch("07 | Warm interior backing", M_WARM_ROOM) neutral_rooms = Batch("08 | Neutral interior backing", M_NEUTRAL_ROOM) blinds = Batch("09 | Window blinds", M_BLIND) roofs = Batch("10 | Roof membranes", M_ROOF) steel = Batch("11 | Crown, railings and equipment", M_STEEL, bevel=0.015) infill = Batch("12 | Crown dark infill", M_INFILL) antenna = Batch("13 | Antenna", M_ANTENNA, bevel=0.008) brass = Batch("14 | Entrance metalwork", M_BRASS, bevel=0.012) beacons = Batch("15 | Aviation beacons", M_BEACON) def face_specs(width, depth): # Horizontal tangent, outward normal, facade span, outer plane. return [ ((1, 0), (0, -1), width, depth / 2), ((-1, 0), (0, 1), width, depth / 2), ((0, 1), (1, 0), depth, width / 2), ((0, -1), (-1, 0), depth, width / 2) ] def facade_box(batch, u, n, horizontal, outward, z, width, depth, height): center = ( u[0] * horizontal + n[0] * outward, u[1] * horizontal + n[1] * outward, z ) size = ( (width, depth, height) if u[0] else (depth, width, height) ) batch.box(center, size) # ============================================================ # MAIN BUILDING # Each tier includes real recessed panes, frames and piers. # ============================================================ TIERS = [ # Bottom, top, width, depth, facade floor rows. (0.0, 21.6, 129.0, 60.0, 5), (21.6, 43.2, 115.0, 55.0, 6), (43.2, 64.8, 96.0, 50.0, 6), (64.8, 79.2, 78.0, 46.0, 4), (79.2, 266.4, 64.0, 43.0, 50), (266.4, 288.0, 57.0, 38.0, 6), (288.0, 302.4, 49.0, 33.0, 4), (302.4, 313.2, 40.0, 28.0, 3), (313.2, 320.4, 33.0, 25.0, 2) ] window_count = 0 def build_facades(z0, z1, width, depth, floors): global window_count stone.box( (0, 0, (z0 + z1) / 2), (width - 1.6, depth - 1.6, z1 - z0) ) for u, n, span, outer in face_specs(width, depth): bays = max(2, int((span - 2.0) / 3.10)) pitch = (span - 2.0) / bays pane_width = pitch * 0.57 centers = [ -(span - 2.0) / 2 + (j + 0.5) * pitch for j in range(bays) ] # Continuous vertical limestone piers. cursor = -span / 2 pier_intervals = [] for x in centers: pier_intervals.append((cursor, x - pane_width / 2)) cursor = x + pane_width / 2 pier_intervals.append((cursor, span / 2)) for left, right in pier_intervals: center = (left + right) / 2 facade_box( stone, u, n, center, outer - 0.30, (z0 + z1) / 2, right - left, 0.60, z1 - z0 ) facade_box( trim, u, n, center, outer + 0.015, (z0 + z1) / 2, min(0.17, (right - left) * 0.25), 0.10, z1 - z0 - 0.30 ) def band(bottom, top): if top - bottom <= 0.02: return facade_box( stone, u, n, 0, outer - 0.33, (bottom + top) / 2, span, 0.36, top - bottom ) for x in centers: facade_box( spandrels, u, n, x, outer - 0.13, (bottom + top) / 2, pane_width - 0.10, 0.028, max(0.04, top - bottom - 0.14) ) floor_height = (z1 - z0) / floors previous_top = z0 for floor in range(floors): floor_z = z0 + floor * floor_height bottom = floor_z + floor_height * 0.19 top = bottom + floor_height * 0.64 height = top - bottom middle = (bottom + top) / 2 band(previous_top, bottom) previous_top = top for x in centers: window_count += 1 roll = RNG.random() room = ( warm_rooms if roll < 0.11 else neutral_rooms if roll < 0.17 else dark_rooms ) # Interior backing sits behind the solid glass pane. facade_box( room, u, n, x, outer - 0.65, middle, pane_width - 0.075, 0.055, height - 0.075 ) facade_box( glass, u, n, x, outer - 0.265, middle, pane_width - 0.09, 0.026, height - 0.09 ) # Perimeter frames. for side in (-1, 1): facade_box( frames, u, n, x + side * (pane_width / 2 - 0.035), outer - 0.16, middle, 0.07, 0.10, height ) for z in (bottom + 0.035, top - 0.035): facade_box( frames, u, n, x, outer - 0.16, z, pane_width, 0.10, 0.07 ) # Vertical divider and sash meeting rail. facade_box( frames, u, n, x, outer - 0.16, middle, 0.045, 0.10, height - 0.10 ) facade_box( frames, u, n, x, outer - 0.16, bottom + height * 0.49, pane_width - 0.10, 0.10, 0.045 ) # Varied roller blinds behind the glass. if RNG.random() < 0.23: covered = height * RNG.uniform(0.18, 0.72) facade_box( blinds, u, n, x, outer - 0.53, top - 0.08 - covered / 2, pane_width - 0.14, 0.018, covered ) band(previous_top, z1) def build_roof(z, width, depth, next_dims=None, observation=False): trim.box( (0, 0, z - 0.11), (width + 0.38, depth + 0.38, 0.28) ) roofs.box( (0, 0, z + 0.045), (width - 0.2, depth - 0.2, 0.09) ) if not observation: for u, n, span, outer in face_specs(width, depth): facade_box( stone, u, n, 0, outer - 0.12, z + 0.43, span, 0.28, 0.78 ) facade_box( trim, u, n, 0, outer - 0.12, z + 0.84, span + 0.12, 0.40, 0.10 ) if next_dims and not observation: placed = 0 for attempt in range(50): x = RNG.uniform(-width / 2 + 3, width / 2 - 3) y = RNG.uniform(-depth / 2 + 3, depth / 2 - 3) if ( abs(x) < next_dims[0] / 2 + 2 and abs(y) < next_dims[1] / 2 + 2 ): continue steel.box((x, y, z + 0.65), (2.1, 1.5, 1.05)) steel.rod( (x, y, z + 1.18), (x, y, z + 1.30), 0.52, sides=24 ) infill.rod( (x, y, z + 1.30), (x, y, z + 1.32), 0.42, sides=24 ) placed += 1 if placed == 3: break for index, tier in enumerate(TIERS): build_facades(*tier) z0, z1, width, depth, floors = tier next_dims = TIERS[index + 1][2:4] if index + 1 < len(TIERS) else None build_roof( z1, width, depth, next_dims, observation=(index == len(TIERS) - 1) ) # ============================================================ # OBSERVATION DECK AND FLUTED CROWN # ============================================================ trim.box((0, 0, 320.57), (37.0, 29.0, 0.36)) roofs.box((0, 0, 320.78), (36.5, 28.5, 0.08)) for u, n, span, outer in face_specs(36.5, 28.5): count = math.ceil(span / 0.85) for j in range(count + 1): x = -span / 2 + span * j / count facade_box( steel, u, n, x, outer, 322.1, 0.065, 0.065, 2.8 ) for z in (321.1, 322.2, 323.5): facade_box( steel, u, n, 0, outer, z, span, 0.09, 0.09 ) CROWN = [ (320.85, 329.0, 23.0, 19.0), (329.0, 352.0, 19.0, 16.0), (352.0, 367.0, 15.0, 13.0), (367.0, 375.0, 11.5, 10.0) ] for z0, z1, width, depth in CROWN: infill.octagonal(width, depth, z0, z1) steel.octagonal(width + 0.44, depth + 0.44, z0, z0 + 0.35) steel.octagonal(width + 0.44, depth + 0.44, z1 - 0.35, z1) outline = octagon(width, depth) for a, b in zip(outline, outline[1:] + outline[:1]): divisions = max(1, math.ceil((b - a).length / 0.72)) for j in range(divisions): p = a.lerp(b, j / divisions) steel.rod( (p.x, p.y, z0 + 0.15), (p.x, p.y, z1 - 0.15), 0.115, sides=12 ) z = z0 + 3.4 while z < z1 - 0.35: steel.octagonal( width + 0.12, depth + 0.12, z, z + 0.16 ) z += 3.4 steel.octagonal(11.5, 10.0, 375.0, 381.0, 2.8, 2.8) # Segmented broadcast antenna; top terminates at 443.2 m. MAST = [ (381.0, 392.0, 1.28, 1.05), (392.0, 409.0, 1.00, 0.79), (409.0, 423.0, 0.72, 0.51), (423.0, 436.0, 0.43, 0.24), (436.0, 443.2, 0.18, 0.035) ] for z0, z1, r0, r1 in MAST: antenna.rod((0, 0, z0), (0, 0, z1), r0, r1, sides=32) z = z0 + 2.0 while z < z1: radius = r0 + (r1 - r0) * (z - z0) / (z1 - z0) steel.rod( (0, 0, z - 0.08), (0, 0, z + 0.08), radius + 0.13, sides=24 ) z += 4.0 # Vertical antenna panel arrays. for z0, height, radius in ( (387.0, 8.0, 1.5), (398.0, 8.0, 1.15), (412.0, 7.0, 0.92) ): for angle in (0, math.pi / 2, math.pi, 3 * math.pi / 2): x, y = math.cos(angle), math.sin(angle) antenna.box( (x * radius, y * radius, z0 + height / 2), (0.18, 0.42, height) if abs(x) > 0.5 else (0.42, 0.18, height) ) for z, x in ((391.5, 1.3), (409.0, 0.98), (426.0, 0.65), (439.0, 0.34)): beacons.rod((x, 0, z - 0.12), (x, 0, z + 0.12), 0.13) # ============================================================ # ART DECO ENTRANCE ON THE EAST FACE # ============================================================ u, n = (0, 1), (1, 0) outer = TIERS[0][2] / 2 facade_box( dark_rooms, u, n, 0, outer + 0.20, 6.0, 15.8, 0.10, 12.0 ) for y in (-8.1, 8.1): facade_box( trim, u, n, y, outer + 0.48, 6.0, 0.85, 1.15, 12.0 ) for offset in (-0.22, 0.0, 0.22): facade_box( brass, u, n, y + offset, outer + 1.07, 6.0, 0.045, 0.07, 11.6 ) facade_box( trim, u, n, 0, outer + 0.48, 11.35, 17.0, 1.15, 1.4 ) facade_box( glass, u, n, 0, outer + 0.31, 8.0, 14.8, 0.03, 4.3 ) for y in (-5.2, -2.6, 0.0, 2.6, 5.2): facade_box( glass, u, n, y, outer + 0.34, 2.75, 1.95, 0.035, 5.0 ) for edge in (-1, 1): facade_box( brass, u, n, y + edge * 1.0, outer + 0.43, 2.75, 0.09, 0.12, 5.15 ) facade_box( brass, u, n, y, outer + 0.43, 5.28, 2.1, 0.12, 0.10 ) # Projecting entrance canopy. brass.box((outer + 1.6, 0, 5.7), (3.2, 15.0, 0.20)) font = bpy.data.curves.new("Entrance lettering", "FONT") font.body = "EMPIRE STATE" font.align_x = "CENTER" font.align_y = "CENTER" font.size = 0.95 font.space_character = 1.15 font.extrude = 0.025 font.bevel_depth = 0.008 font.bevel_resolution = 3 font.materials.append(M_BRASS) sign = bpy.data.objects.new("EMPIRE STATE | entrance sign", font) HERO.objects.link(sign) sign.location = (outer + 1.10, 0, 11.35) sign.rotation_euler = (math.pi / 2, 0, math.pi / 2) # ============================================================ # CITY CONTEXT MATERIAL # Procedural windows are used only for background buildings. # ============================================================ def city_material(name, masonry_color): mat = principled(name, masonry_color, 0.75) nodes, links = mat.node_tree.nodes, mat.node_tree.links bs = nodes.get("Principled BSDF") def op(operation, a, b=None): node = nodes.new("ShaderNodeMath") node.operation = operation for index, value in enumerate((a, b)): if value is None: continue if isinstance(value, (int, float)): node.inputs[index].default_value = value else: links.new(value, node.inputs[index]) return node.outputs[0] geo = nodes.new("ShaderNodeNewGeometry") position = nodes.new("ShaderNodeSeparateXYZ") normal = nodes.new("ShaderNodeSeparateXYZ") links.new(geo.outputs["Position"], position.inputs[0]) links.new(geo.outputs["Normal"], normal.inputs[0]) horizontal = op("ADD", position.outputs["X"], position.outputs["Y"]) column = op("FRACT", op("MULTIPLY", horizontal, 1 / 3.3)) row = op("FRACT", op("MULTIPLY", position.outputs["Z"], 1 / 3.7)) horizontal_mask = op( "MULTIPLY", op("GREATER_THAN", column, 0.23), op("LESS_THAN", column, 0.76) ) vertical_mask = op( "MULTIPLY", op("GREATER_THAN", row, 0.19), op("LESS_THAN", row, 0.82) ) wall_mask = op("SUBTRACT", 1.0, op("ABSOLUTE", normal.outputs["Z"])) windows = op( "MULTIPLY", op("MULTIPLY", horizontal_mask, vertical_mask), wall_mask ) mix = nodes.new("ShaderNodeMixRGB") mix.inputs[1].default_value = (*masonry_color, 1.0) mix.inputs[2].default_value = (0.018, 0.03, 0.046, 1.0) links.new(windows, mix.inputs[0]) links.new(mix.outputs[0], bs.inputs["Base Color"]) links.new(op("MULTIPLY", windows, 0.6), bs.inputs["Metallic"]) links.new( op("SUBTRACT", 0.75, op("MULTIPLY", windows, 0.55)), bs.inputs["Roughness"] ) bump = nodes.new("ShaderNodeBump") bump.invert = True bump.inputs["Strength"].default_value = 0.35 bump.inputs["Distance"].default_value = 0.05 links.new(windows, bump.inputs["Height"]) links.new(bump.outputs["Normal"], bs.inputs["Normal"]) return mat # ============================================================ # GROUND, BLOCKS AND STREET DETAILS # ============================================================ ground = Batch("Ground | continuous asphalt", M_ASPHALT, ENVIRONMENT) ground.box((0, 0, -0.30), (20000, 20000, 0.30)) paving = Batch("Sidewalk blocks", M_PAVING, CITY, bevel=0.08) paving.box((0, 0, -0.11), (146, 80, 0.22)) markings = Batch("Street markings | white", M_PAINT, CITY) yellow_lines = Batch("Street markings | yellow", M_YELLOW, CITY) city_roofs = Batch("Context | dark roofs", M_ROOF, CITY) if ADD_CITY: city_batches = [ Batch( f"Context buildings | palette {i + 1}", city_material(f"Context facade {i + 1}", color), CITY, bevel=0.06 ) for i, color in enumerate(( (0.27, 0.245, 0.21), (0.22, 0.235, 0.24), (0.30, 0.205, 0.15), (0.37, 0.355, 0.32) )) ] toward_camera = Vector((CAMERA_POSITION.x, CAMERA_POSITION.y, 0)) camera_distance = toward_camera.length toward_camera.normalize() screen_right = Vector((-toward_camera.y, toward_camera.x, 0)) for ix in range(-8, 9): for iy in range(-10, 11): if ix == 0 and iy == 0: continue cx, cy = ix * 166.0, iy * 110.0 paving.box((cx, cy, -0.11), (146, 80, 0.22)) for offset in (-35.0, 35.0): x = cx + offset y = cy + RNG.uniform(-3, 3) width = RNG.uniform(52, 62) depth = RNG.uniform(49, 64) height = RNG.uniform(20, 135) if RNG.random() < 0.13: height += 65 location = Vector((x, y, 0)) forward = location.dot(toward_camera) sideways = abs(location.dot(screen_right)) # Keep the hero's lower facade reasonably visible. if 0 < forward < camera_distance and sideways < 150: clear_height = max( 7.0, CAMERA_POSITION.z * forward / camera_distance - 30 ) height = min(height, clear_height) batch = RNG.choice(city_batches) lower = height * 0.78 batch.box( (x, y, lower / 2), (width, depth, lower) ) batch.box( (x, y, (lower + height) / 2), (width * 0.84, depth * 0.86, height - lower) ) city_roofs.box( (x, y, height + 0.06), (width * 0.84 + 0.2, depth * 0.86 + 0.2, 0.12) ) # Low-detail distant skyline. for _ in range(700): angle = RNG.uniform(0, math.tau) radius = RNG.uniform(1800, 5200) x, y = radius * math.cos(angle), radius * math.sin(angle) width = RNG.uniform(35, 100) depth = RNG.uniform(35, 95) height = RNG.uniform(25, 175) RNG.choice(city_batches).box( (x, y, height / 2), (width, depth, height) ) # Dashed lane markings around the hero. for iy in range(-3, 4): y = (iy + 0.5) * 110 for ix in range(-3, 4): for step in range(-4, 5): x = ix * 166 + step * 14 for offset in (-0.20, 0.20): yellow_lines.box( (x, y + offset, -0.137), (5.0, 0.10, 0.016) ) for ix in range(-3, 4): x = (ix + 0.5) * 166 for iy in range(-3, 4): for step in range(-3, 4): y = iy * 110 + step * 12 yellow_lines.box( (x, y, -0.137), (0.13, 4.5, 0.016) ) # Crosswalks around the main block. for y in (-55, 55): for x in (-65, 65): for j in range(8): markings.box( (x + (j - 3.5) * 0.75, y, -0.135), (0.43, 25, 0.02) ) for x in (-83, 83): for y in (-34, 34): for j in range(8): markings.box( (x, y + (j - 3.5) * 0.75, -0.135), (18, 0.43, 0.02) ) # Small background vehicles, including yellow taxis. car_materials = [ principled("Vehicles | taxi yellow", (0.74, 0.34, 0.025), 0.27, 0.5), principled("Vehicles | dark blue", (0.018, 0.035, 0.065), 0.24, 0.65), principled("Vehicles | silver", (0.39, 0.42, 0.44), 0.26, 0.7) ] cars = [ Batch(f"Vehicles | body {i}", mat, CITY, bevel=0.14) for i, mat in enumerate(car_materials) ] car_glass = Batch( "Vehicles | glazing", principled("Vehicle glazing", (0.025, 0.045, 0.06), 0.14, 0.5), CITY, bevel=0.10 ) tires = Batch( "Vehicles | tires", principled("Tire rubber", (0.009, 0.01, 0.012), 0.88), CITY ) for _ in range(65): x = RNG.uniform(-470, 470) if abs((x % 166) - 83) < 14: continue y = RNG.choice((-61, -49, 49, 61)) body = RNG.choice(cars) body.box((x, y, 0.48), (4.4, 1.86, 0.58)) car_glass.box((x - 0.15, y, 0.98), (2.4, 1.60, 0.50)) for wheel_x in (-1.35, 1.35): for wheel_y in (-0.86, 0.86): tires.rod( (x + wheel_x, y + wheel_y - 0.10, 0.17), (x + wheel_x, y + wheel_y + 0.10, 0.17), 0.31, sides=16 ) # ============================================================ # ATMOSPHERE # Finite, very low-density volume rather than opaque fog. # ============================================================ haze = None if ADD_HAZE: haze_material = bpy.data.materials.new("Atmosphere | subtle haze") haze_material.use_nodes = True nodes = haze_material.node_tree.nodes nodes.clear() output = nodes.new("ShaderNodeOutputMaterial") scatter = nodes.new("ShaderNodeVolumeScatter") scatter.inputs["Color"].default_value = (0.82, 0.89, 1.0, 1.0) scatter.inputs["Density"].default_value = 0.000025 scatter.inputs["Anisotropy"].default_value = 0.25 haze_material.node_tree.links.new( scatter.outputs["Volume"], output.inputs["Volume"] ) haze = Batch("Atmospheric haze volume", haze_material, ENVIRONMENT) haze.box((0, 0, 750), (14000, 14000, 1700)) # Create mesh objects. for batch in BATCHES: batch.finish() if haze and haze.object: haze.object.display_type = "WIRE" # ============================================================ # CAMERAS # ============================================================ def aim_at(obj, target): direction = Vector(target) - obj.location obj.rotation_euler = direction.to_track_quat("-Z", "Y").to_euler() def camera(name, position, target, lens): data = bpy.data.cameras.new(name) obj = bpy.data.objects.new(name, data) CAMERAS.objects.link(obj) obj.location = position data.lens = lens data.sensor_fit = "VERTICAL" data.sensor_height = 36.0 data.clip_start = 0.1 data.clip_end = 20000 data.dof.use_dof = False aim_at(obj, target) return obj scene.camera = camera( "CAM | Hero architectural portrait", CAMERA_POSITION, (0, 0, 218), 58 ) camera( "CAM | Crown detail", (155, -230, 365), (0, 0, 377), 65 ) # ============================================================ # PHOTOGRAPHIC GOLDEN-HOUR LIGHTING # ============================================================ sun_elevation = math.radians(13.0) sun_azimuth = math.radians(-115.0) world = bpy.data.worlds.new("World | golden-hour Nishita sky") world.use_nodes = True scene.world = world nodes = world.node_tree.nodes links = world.node_tree.links nodes.clear() world_output = nodes.new("ShaderNodeOutputWorld") background = nodes.new("ShaderNodeBackground") background.inputs["Strength"].default_value = 0.30 sky = nodes.new("ShaderNodeTexSky") sky.sky_type = "NISHITA" sky.sun_disc = False # Separate sun below avoids double illumination. sky.sun_elevation = sun_elevation sky.sun_rotation = sun_azimuth % math.tau sky.altitude = 0.2 sky.air_density = 1.0 sky.dust_density = 1.6 sky.ozone_density = 1.0 links.new(sky.outputs["Color"], background.inputs["Color"]) links.new(background.outputs["Background"], world_output.inputs["Surface"]) sun_data = bpy.data.lights.new("Sun | realistic angular diameter", "SUN") sun_data.energy = 3.0 sun_data.color = (1.0, 0.82, 0.64) sun_data.angle = math.radians(0.526) sun = bpy.data.objects.new("Sun | low raking architectural light", sun_data) LIGHTING.objects.link(sun) sun.location = Vector(( math.cos(sun_elevation) * math.cos(sun_azimuth), math.cos(sun_elevation) * math.sin(sun_azimuth), math.sin(sun_elevation) )) * 1000 aim_at(sun, (0, 0, 0)) # Subtle warm-white architectural uplights at the crown. for index, position in enumerate(( (14, 0, 321.2), (-14, 0, 321.2), (0, 12, 321.2), (0, -12, 321.2) )): data = bpy.data.lights.new(f"Crown uplight {index + 1}", "AREA") data.energy = 2400 data.color = (1.0, 0.83, 0.62) data.shape = "RECTANGLE" data.size = 3.0 data.size_y = 1.0 obj = bpy.data.objects.new(data.name, data) LIGHTING.objects.link(obj) obj.location = position aim_at(obj, (0, 0, 346)) # ============================================================ # CYCLES QUALITY SETTINGS # ============================================================ scene.render.engine = "CYCLES" def configure_device(): addon = bpy.context.preferences.addons.get("cycles") if addon: preferences = addon.preferences for backend in ("OPTIX", "CUDA", "HIP", "METAL", "ONEAPI"): try: preferences.compute_device_type = backend preferences.get_devices() available = [ device for device in preferences.devices if device.type == backend ] if available: for device in preferences.devices: device.use = device.type == backend scene.cycles.device = "GPU" return backend except Exception: continue scene.cycles.device = "CPU" return "CPU" device_name = configure_device() scene.cycles.samples = 4096 if FINAL else 128 scene.cycles.use_adaptive_sampling = True scene.cycles.adaptive_threshold = 0.003 if FINAL else 0.03 scene.cycles.adaptive_min_samples = 64 if FINAL else 16 scene.cycles.use_denoising = True scene.cycles.denoiser = "OPENIMAGEDENOISE" scene.cycles.denoising_input_passes = "RGB_ALBEDO_NORMAL" scene.cycles.denoising_prefilter = "ACCURATE" scene.cycles.max_bounces = 16 scene.cycles.diffuse_bounces = 6 scene.cycles.glossy_bounces = 8 scene.cycles.transmission_bounces = 12 scene.cycles.transparent_max_bounces = 8 scene.cycles.volume_bounces = 2 scene.cycles.use_light_tree = True scene.cycles.caustics_reflective = False scene.cycles.caustics_refractive = False scene.cycles.sample_clamp_direct = 0.0 scene.cycles.sample_clamp_indirect = 10.0 scene.cycles.seed = 1931 scene.render.resolution_x = 6144 if FINAL else 1152 scene.render.resolution_y = 8192 if FINAL else 1536 scene.render.resolution_percentage = 100 scene.render.pixel_aspect_x = 1.0 scene.render.pixel_aspect_y = 1.0 scene.render.filter_size = 1.25 scene.render.film_transparent = False scene.render.use_simplify = False scene.render.use_persistent_data = True scene.view_settings.view_transform = "AgX" try: scene.view_settings.look = "AgX - Medium High Contrast" except TypeError: pass scene.view_settings.exposure = -0.4 scene.view_settings.gamma = 1.0 # Very restrained highlight bloom. scene.use_nodes = True nodes = scene.node_tree.nodes links = scene.node_tree.links nodes.clear() render_layer = nodes.new("CompositorNodeRLayers") glare = nodes.new("CompositorNodeGlare") glare.glare_type = "FOG_GLOW" glare.quality = "HIGH" glare.threshold = 2.5 glare.size = 8 glare.mix = -0.92 composite = nodes.new("CompositorNodeComposite") links.new(render_layer.outputs["Image"], glare.inputs["Image"]) links.new(glare.outputs["Image"], composite.inputs["Image"]) # ============================================================ # SAVE AND RENDER # ============================================================ scene.render.image_settings.file_format = "PNG" scene.render.image_settings.color_mode = "RGB" scene.render.image_settings.color_depth = "16" scene.render.image_settings.compression = 25 scene.render.filepath = str(OUTPUT / "Empire_State.png") # Open the saved project in camera view where possible. for screen in bpy.data.screens: for area in screen.areas: if area.type == "VIEW_3D": area.spaces.active.clip_end = 20000 area.spaces.active.region_3d.view_perspective = "CAMERA" bpy.ops.wm.save_as_mainfile( filepath=str(OUTPUT / "Empire_State.blend") ) print(f"\nCreated {window_count:,} individual facade windows.") print(f"Render device: {device_name}") print(f"Output folder: {OUTPUT}\n") if RENDER_NOW: bpy.ops.render.render(write_still=True) # Preserve an HDR version in addition to the display-ready PNG. scene.render.image_settings.file_format = "OPEN_EXR" scene.render.image_settings.color_depth = "32" scene.render.image_settings.exr_codec = "ZIP" bpy.data.images["Render Result"].save_render( filepath=str(OUTPUT / "Empire_State.exr"), scene=scene ) # Restore convenient settings for future renders. scene.render.image_settings.file_format = "PNG" scene.render.image_settings.color_depth = "16" print("Finished: Empire_State.blend, Empire_State.png, Empire_State.exr") ``` You can also run it unattended after saving it as `empire_state.py`: ```bash blender --background --python empire_state.py ``` **Recommended workflow:** render `PREVIEW` first to check the composition, then switch to `FINAL`. For a less demanding final render, use **3072 × 4096** at **2048 samples**; the modeling, materials, and lighting remain unchanged.

Mine