Initial commit: cad-building-showcase skill
Agent-led CAD-drawing → 3D web showcase pipeline. Inspects CAD reports, maps layers/floors, extracts a normalized building spec (with block-probed glazing and audit gates), builds Blender/trimesh GLB variants, and assembles a Three.js web viewer. Includes XREF-shell detection and a regression test. Large inputs/outputs (work/, outputs/, source_cad/, renders) are gitignored. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
757
scripts/build_blender_showcase.py
Executable file
757
scripts/build_blender_showcase.py
Executable file
@@ -0,0 +1,757 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Generate a Blender scene, GLB, preview PNG, and model metadata from building_spec.json."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import math
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
CATEGORY_DRAW_ORDER = (
|
||||
"grid",
|
||||
"floor_lines",
|
||||
"detail_lines",
|
||||
"doors",
|
||||
"railings",
|
||||
"roof",
|
||||
"glazing",
|
||||
"walls",
|
||||
"columns",
|
||||
"beams",
|
||||
)
|
||||
|
||||
DEFAULT_CATEGORY_COLORS = {
|
||||
"slab": "#c8ccc2",
|
||||
"roof": "#b8ae98",
|
||||
"walls": "#d4cbb8",
|
||||
"glazing": "#79b8c9",
|
||||
"columns": "#f58a1f",
|
||||
"beams": "#1f66c2",
|
||||
"railings": "#6f746d",
|
||||
"doors": "#8a6a45",
|
||||
"detail_lines": "#8c9088",
|
||||
"floor_lines": "#18a058",
|
||||
"grid": "#20242a",
|
||||
}
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
argv = sys.argv
|
||||
if "--" in argv:
|
||||
argv = argv[argv.index("--") + 1 :]
|
||||
else:
|
||||
argv = []
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--spec", required=True, help="Path to building_spec.json")
|
||||
parser.add_argument("--out-dir", required=True, help="Output folder")
|
||||
parser.add_argument("--name", default="cad_building_showcase", help="Base output file name")
|
||||
parser.add_argument("--render", action="store_true", default=True, help="Render preview PNG")
|
||||
return parser.parse_args(argv)
|
||||
|
||||
|
||||
def clear_scene(bpy):
|
||||
bpy.ops.object.select_all(action="SELECT")
|
||||
bpy.ops.object.delete()
|
||||
for datablocks in (
|
||||
bpy.data.meshes,
|
||||
bpy.data.curves,
|
||||
bpy.data.materials,
|
||||
bpy.data.images,
|
||||
bpy.data.lights,
|
||||
bpy.data.cameras,
|
||||
):
|
||||
for item in list(datablocks):
|
||||
if item.users == 0:
|
||||
datablocks.remove(item)
|
||||
|
||||
|
||||
def make_material(bpy, name: str, color_hex: str, alpha: float = 1.0, roughness: float = 0.75):
|
||||
color_hex = color_hex.lstrip("#")
|
||||
r = int(color_hex[0:2], 16) / 255.0
|
||||
g = int(color_hex[2:4], 16) / 255.0
|
||||
b = int(color_hex[4:6], 16) / 255.0
|
||||
color = (r, g, b, alpha)
|
||||
mat = bpy.data.materials.new(name)
|
||||
mat.diffuse_color = color
|
||||
mat.use_nodes = True
|
||||
bsdf = mat.node_tree.nodes.get("Principled BSDF")
|
||||
if bsdf:
|
||||
bsdf.inputs["Base Color"].default_value = color
|
||||
bsdf.inputs["Roughness"].default_value = roughness
|
||||
if "Alpha" in bsdf.inputs:
|
||||
bsdf.inputs["Alpha"].default_value = alpha
|
||||
if alpha < 1.0:
|
||||
mat.blend_method = "BLEND"
|
||||
mat.show_transparent_back = True
|
||||
return mat
|
||||
|
||||
|
||||
def create_box_mesh(bpy, name: str, boxes: list[list[float]], material, floor_key: str, category: str):
|
||||
verts = []
|
||||
faces = []
|
||||
for box in boxes:
|
||||
x1, y1, x2, y2, z0, z1 = box
|
||||
idx = len(verts)
|
||||
verts.extend(
|
||||
[
|
||||
(x1, y1, z0),
|
||||
(x2, y1, z0),
|
||||
(x2, y2, z0),
|
||||
(x1, y2, z0),
|
||||
(x1, y1, z1),
|
||||
(x2, y1, z1),
|
||||
(x2, y2, z1),
|
||||
(x1, y2, z1),
|
||||
]
|
||||
)
|
||||
faces.extend(
|
||||
[
|
||||
(idx + 0, idx + 1, idx + 2, idx + 3),
|
||||
(idx + 4, idx + 7, idx + 6, idx + 5),
|
||||
(idx + 0, idx + 4, idx + 5, idx + 1),
|
||||
(idx + 1, idx + 5, idx + 6, idx + 2),
|
||||
(idx + 2, idx + 6, idx + 7, idx + 3),
|
||||
(idx + 3, idx + 7, idx + 4, idx + 0),
|
||||
]
|
||||
)
|
||||
mesh = bpy.data.meshes.new(f"{name}Mesh")
|
||||
mesh.from_pydata(verts, [], faces)
|
||||
mesh.update()
|
||||
mesh.validate(verbose=False) # drop degenerate faces so exported normals never become NaN
|
||||
obj = bpy.data.objects.new(name, mesh)
|
||||
bpy.context.collection.objects.link(obj)
|
||||
obj.data.materials.append(material)
|
||||
obj["floor"] = floor_key
|
||||
obj["category"] = category
|
||||
return obj
|
||||
|
||||
|
||||
def clean_polygon_points(coords: list[list[float]]) -> list[tuple[float, float]]:
|
||||
points = [(float(x), float(y)) for x, y in coords]
|
||||
if len(points) > 1 and points[0] == points[-1]:
|
||||
points = points[:-1]
|
||||
cleaned = []
|
||||
for point in points:
|
||||
if not cleaned or point != cleaned[-1]:
|
||||
cleaned.append(point)
|
||||
return cleaned
|
||||
|
||||
|
||||
def create_polygon_prism_mesh(
|
||||
bpy,
|
||||
name: str,
|
||||
polygons: list[list[list[float]]],
|
||||
z0: float,
|
||||
z1: float,
|
||||
material,
|
||||
floor_key: str,
|
||||
category: str,
|
||||
):
|
||||
from mathutils import Vector
|
||||
from mathutils.geometry import tessellate_polygon
|
||||
|
||||
verts = []
|
||||
faces = []
|
||||
for coords in polygons:
|
||||
points = clean_polygon_points(coords)
|
||||
if len(points) < 3:
|
||||
continue
|
||||
base = len(verts)
|
||||
verts.extend([(x, y, z0) for x, y in points])
|
||||
verts.extend([(x, y, z1) for x, y in points])
|
||||
n = len(points)
|
||||
try:
|
||||
triangles = tessellate_polygon([[Vector((x, y, 0.0)) for x, y in points]])
|
||||
except Exception:
|
||||
triangles = []
|
||||
for triangle in triangles:
|
||||
faces.append(tuple(base + n + index for index in triangle))
|
||||
faces.append(tuple(base + index for index in reversed(triangle)))
|
||||
for index in range(n):
|
||||
next_index = (index + 1) % n
|
||||
faces.append((base + index, base + next_index, base + n + next_index, base + n + index))
|
||||
if not verts or not faces:
|
||||
return None
|
||||
mesh = bpy.data.meshes.new(f"{name}Mesh")
|
||||
mesh.from_pydata(verts, [], faces)
|
||||
mesh.update()
|
||||
mesh.validate(verbose=False) # drop degenerate faces so exported normals never become NaN
|
||||
obj = bpy.data.objects.new(name, mesh)
|
||||
bpy.context.collection.objects.link(obj)
|
||||
obj.data.materials.append(material)
|
||||
obj["floor"] = floor_key
|
||||
obj["category"] = category
|
||||
return obj
|
||||
|
||||
|
||||
def segment_prism(segment: dict, z0: float, z1: float):
|
||||
x1, y1 = segment["start"]
|
||||
x2, y2 = segment["end"]
|
||||
dx = x2 - x1
|
||||
dy = y2 - y1
|
||||
length = math.hypot(dx, dy)
|
||||
if length <= 1e-7:
|
||||
return None
|
||||
half_width = max(float(segment.get("width", 0.1)), 0.005) / 2.0
|
||||
nx = -dy / length * half_width
|
||||
ny = dx / length * half_width
|
||||
return [
|
||||
(x1 + nx, y1 + ny, z0),
|
||||
(x2 + nx, y2 + ny, z0),
|
||||
(x2 - nx, y2 - ny, z0),
|
||||
(x1 - nx, y1 - ny, z0),
|
||||
(x1 + nx, y1 + ny, z1),
|
||||
(x2 + nx, y2 + ny, z1),
|
||||
(x2 - nx, y2 - ny, z1),
|
||||
(x1 - nx, y1 - ny, z1),
|
||||
]
|
||||
|
||||
|
||||
def create_segment_mesh(bpy, name: str, segments: list[dict], z0: float, z1: float, material, floor_key: str, category: str):
|
||||
verts = []
|
||||
faces = []
|
||||
for segment in segments:
|
||||
segment_z0 = float(segment.get("_z0", z0))
|
||||
segment_z1 = float(segment.get("_z1", z1))
|
||||
prism = segment_prism(segment, segment_z0, segment_z1)
|
||||
if not prism:
|
||||
continue
|
||||
idx = len(verts)
|
||||
verts.extend(prism)
|
||||
faces.extend(
|
||||
[
|
||||
(idx + 0, idx + 1, idx + 2, idx + 3),
|
||||
(idx + 4, idx + 7, idx + 6, idx + 5),
|
||||
(idx + 0, idx + 4, idx + 5, idx + 1),
|
||||
(idx + 1, idx + 5, idx + 6, idx + 2),
|
||||
(idx + 2, idx + 6, idx + 7, idx + 3),
|
||||
(idx + 3, idx + 7, idx + 4, idx + 0),
|
||||
]
|
||||
)
|
||||
if not verts:
|
||||
return None
|
||||
mesh = bpy.data.meshes.new(f"{name}Mesh")
|
||||
mesh.from_pydata(verts, [], faces)
|
||||
mesh.update()
|
||||
mesh.validate(verbose=False) # drop degenerate faces so exported normals never become NaN
|
||||
obj = bpy.data.objects.new(name, mesh)
|
||||
bpy.context.collection.objects.link(obj)
|
||||
obj.data.materials.append(material)
|
||||
obj["floor"] = floor_key
|
||||
obj["category"] = category
|
||||
return obj
|
||||
|
||||
|
||||
def create_label(bpy, name: str, body: str, location: tuple[float, float, float], size: float, material):
|
||||
curve = bpy.data.curves.new(f"{name}Curve", "FONT")
|
||||
curve.body = body
|
||||
curve.align_x = "LEFT"
|
||||
curve.align_y = "CENTER"
|
||||
curve.size = size
|
||||
curve.extrude = 0.02
|
||||
obj = bpy.data.objects.new(name, curve)
|
||||
obj.location = location
|
||||
bpy.context.collection.objects.link(obj)
|
||||
obj.data.materials.append(material)
|
||||
return obj
|
||||
|
||||
|
||||
def is_roof_floor(floor_key: str, floor: dict) -> bool:
|
||||
text = f"{floor_key} {floor.get('name', '')}".upper()
|
||||
return "RF" in text or "ROOF" in text or "屋顶" in text or "屋面" in text
|
||||
|
||||
|
||||
def z_window_for_category(category: str, z: float, height: float, floor_key: str, floor: dict) -> tuple[float, float]:
|
||||
if category in {"walls", "columns", "glazing"}:
|
||||
if category == "columns" and is_roof_floor(floor_key, floor):
|
||||
return z, z + min(height, 1.15)
|
||||
return z, z + height
|
||||
if category == "beams":
|
||||
return z + max(height - 0.55, 0.1), z + height
|
||||
if category == "roof":
|
||||
return z - 0.35, z + 0.08
|
||||
if category == "railings":
|
||||
return z + 0.05, z + min(1.20, height)
|
||||
if category == "doors":
|
||||
return z + 0.02, z + min(2.30, height)
|
||||
if category in {"floor_lines", "detail_lines"}:
|
||||
return z + 0.03, z + 0.09
|
||||
if category == "grid":
|
||||
return z + 0.01, z + 0.04
|
||||
return z + 0.03, z + min(0.12, height)
|
||||
|
||||
|
||||
def union_bounds(bounds_list: list[list[float]]) -> list[float] | None:
|
||||
bounds = [math.inf, math.inf, -math.inf, -math.inf]
|
||||
for item in bounds_list:
|
||||
if not item:
|
||||
continue
|
||||
bounds[0] = min(bounds[0], float(item[0]))
|
||||
bounds[1] = min(bounds[1], float(item[1]))
|
||||
bounds[2] = max(bounds[2], float(item[2]))
|
||||
bounds[3] = max(bounds[3], float(item[3]))
|
||||
if not math.isfinite(bounds[0]):
|
||||
return None
|
||||
return bounds
|
||||
|
||||
|
||||
def bounds_from_floor_keys(spec: dict, floor_keys: list[str]) -> list[float] | None:
|
||||
return union_bounds(
|
||||
[
|
||||
spec.get("floors", {}).get(str(key), {}).get("bounds")
|
||||
for key in floor_keys
|
||||
if spec.get("floors", {}).get(str(key), {}).get("bounds")
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
def footprint_polygons_from_floor_keys(spec: dict, floor_keys: list[str]) -> list[list[list[float]]]:
|
||||
polygons = []
|
||||
for key in floor_keys:
|
||||
floor = spec.get("floors", {}).get(str(key))
|
||||
if not floor:
|
||||
continue
|
||||
polygons.extend(floor.get("footprint", {}).get("polygons", []))
|
||||
return polygons
|
||||
|
||||
|
||||
def generated_roof_bounds(spec: dict) -> list[dict]:
|
||||
config = spec.get("source", {}).get("config", {})
|
||||
roofs = []
|
||||
for index, roof in enumerate(config.get("roof_specs", []), start=1):
|
||||
floor_key = str(roof.get("floor_key") or roof.get("key") or f"ROOF_{index}")
|
||||
floor = spec.get("floors", {}).get(floor_key)
|
||||
if not floor:
|
||||
continue
|
||||
bounds_from = list(roof.get("bounds_from", [floor_key]))
|
||||
footprint_from = list(roof.get("footprint_from", bounds_from))
|
||||
footprint_polygons = (
|
||||
footprint_polygons_from_floor_keys(spec, footprint_from)
|
||||
if config.get("use_footprint_roofs", False) or roof.get("use_footprint", False)
|
||||
else []
|
||||
)
|
||||
bounds = roof.get("bounds") or bounds_from_floor_keys(spec, bounds_from)
|
||||
if not bounds:
|
||||
bounds = floor.get("bounds")
|
||||
if not bounds:
|
||||
continue
|
||||
margin = float(roof.get("margin", 0.4))
|
||||
roofs.append(
|
||||
{
|
||||
"floor_key": floor_key,
|
||||
"z": float(roof.get("z", floor.get("z", 0.0))),
|
||||
"bounds": [
|
||||
float(bounds[0]) - margin,
|
||||
float(bounds[1]) - margin,
|
||||
float(bounds[2]) + margin,
|
||||
float(bounds[3]) + margin,
|
||||
],
|
||||
"thickness": float(roof.get("thickness", 0.35)),
|
||||
"polygons": footprint_polygons,
|
||||
}
|
||||
)
|
||||
if roofs:
|
||||
return roofs
|
||||
|
||||
for key, floor in spec.get("floors", {}).items():
|
||||
if is_roof_floor(key, floor) and floor.get("bounds"):
|
||||
roofs.append(
|
||||
{
|
||||
"floor_key": key,
|
||||
"z": float(floor.get("z", 0.0)),
|
||||
"bounds": floor["bounds"],
|
||||
"thickness": 0.35,
|
||||
"polygons": floor.get("footprint", {}).get("polygons", []),
|
||||
}
|
||||
)
|
||||
return roofs
|
||||
|
||||
|
||||
def point_in_bounds(point: tuple[float, float], bounds: list[float], margin: float) -> bool:
|
||||
x, y = point
|
||||
return bounds[0] - margin <= x <= bounds[2] + margin and bounds[1] - margin <= y <= bounds[3] + margin
|
||||
|
||||
|
||||
def point_in_polygon(point: tuple[float, float], polygon: list[list[float]]) -> bool:
|
||||
x, y = point
|
||||
inside = False
|
||||
if len(polygon) < 3:
|
||||
return False
|
||||
j = len(polygon) - 1
|
||||
for i, current in enumerate(polygon):
|
||||
xi, yi = float(current[0]), float(current[1])
|
||||
xj, yj = float(polygon[j][0]), float(polygon[j][1])
|
||||
crosses = (yi > y) != (yj > y)
|
||||
if crosses:
|
||||
x_at_y = (xj - xi) * (y - yi) / ((yj - yi) or 1e-12) + xi
|
||||
if x < x_at_y:
|
||||
inside = not inside
|
||||
j = i
|
||||
return inside
|
||||
|
||||
|
||||
def point_in_or_near_polygons(point: tuple[float, float], polygons: list[list[list[float]]], margin: float) -> bool:
|
||||
for polygon in polygons:
|
||||
if point_in_polygon(point, polygon):
|
||||
return True
|
||||
points = clean_polygon_points(polygon)
|
||||
for index, start in enumerate(points):
|
||||
end = points[(index + 1) % len(points)]
|
||||
if point_segment_distance(point, start, end) <= margin:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def floor_group(floor_key: str) -> str:
|
||||
if floor_key.startswith("AUX_"):
|
||||
return "AUX"
|
||||
if floor_key in {"B1", "B1M"}:
|
||||
return "BASE"
|
||||
return "MAIN"
|
||||
|
||||
|
||||
def point_segment_distance(point: tuple[float, float], start: tuple[float, float], end: tuple[float, float]) -> float:
|
||||
px, py = point
|
||||
ax, ay = start
|
||||
bx, by = end
|
||||
dx = bx - ax
|
||||
dy = by - ay
|
||||
length_sq = dx * dx + dy * dy
|
||||
if length_sq <= 1e-12:
|
||||
return math.hypot(px - ax, py - ay)
|
||||
t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / length_sq))
|
||||
return math.hypot(px - (ax + t * dx), py - (ay + t * dy))
|
||||
|
||||
|
||||
def column_has_upper_support(point: tuple[float, float], floor_key: str, floor: dict, spec: dict, config: dict) -> bool:
|
||||
floor_top = float(floor["z"]) + float(floor.get("height", 4.2))
|
||||
support_distance = float(config.get("column_support_distance", 1.1))
|
||||
z_tolerance = float(config.get("column_support_z_tolerance", 0.65))
|
||||
structural_categories = set(config.get("column_support_categories", ["walls", "glazing", "columns", "beams"]))
|
||||
require_upper_plate = bool(config.get("column_support_requires_upper_plate", True))
|
||||
allow_plate_only = bool(config.get("column_support_allow_plate_only", False))
|
||||
group = floor_group(floor_key)
|
||||
|
||||
for other_key, other in spec.get("floors", {}).items():
|
||||
if floor_group(other_key) != group:
|
||||
continue
|
||||
other_z = float(other.get("z", 0.0))
|
||||
if not (floor_top - 0.05 <= other_z <= floor_top + z_tolerance):
|
||||
continue
|
||||
upper_polygons = other.get("footprint", {}).get("polygons", [])
|
||||
if upper_polygons:
|
||||
has_upper_plate = point_in_or_near_polygons(point, upper_polygons, support_distance)
|
||||
if has_upper_plate and allow_plate_only:
|
||||
return True
|
||||
if require_upper_plate and not has_upper_plate:
|
||||
continue
|
||||
for category in structural_categories:
|
||||
for segment in other.get("segments", {}).get(category, []):
|
||||
distance = point_segment_distance(point, tuple(segment["start"]), tuple(segment["end"]))
|
||||
if distance <= support_distance:
|
||||
return True
|
||||
|
||||
roof_z_tolerance = float(config.get("column_roof_support_z_tolerance", 0.65))
|
||||
for roof in generated_roof_bounds(spec):
|
||||
if floor_group(str(roof["floor_key"])) != group:
|
||||
continue
|
||||
if abs(float(roof["z"]) - floor_top) > roof_z_tolerance:
|
||||
continue
|
||||
roof_polygons = roof.get("polygons", [])
|
||||
if roof_polygons and point_in_or_near_polygons(point, roof_polygons, support_distance):
|
||||
return True
|
||||
if not roof_polygons and point_in_bounds(point, roof["bounds"], support_distance):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def adjusted_column_segments(segments: list[dict], floor_key: str, floor: dict, spec: dict) -> list[dict]:
|
||||
config = spec.get("source", {}).get("config", {})
|
||||
if not config.get("shorten_unsupported_columns", False):
|
||||
return segments
|
||||
floor_filter = {str(key) for key in config.get("shorten_unsupported_columns_floor_keys", [])}
|
||||
if floor_filter and floor_key not in floor_filter:
|
||||
return segments
|
||||
z = float(floor["z"])
|
||||
height = float(floor.get("height", 4.2))
|
||||
short_height = min(float(config.get("unsupported_column_height", 1.2)), height)
|
||||
adjusted = []
|
||||
for segment in segments:
|
||||
start = segment["start"]
|
||||
end = segment["end"]
|
||||
midpoint = ((start[0] + end[0]) / 2.0, (start[1] + end[1]) / 2.0)
|
||||
item = dict(segment)
|
||||
if not column_has_upper_support(midpoint, floor_key, floor, spec, config):
|
||||
item["_z0"] = z
|
||||
item["_z1"] = z + short_height
|
||||
adjusted.append(item)
|
||||
return adjusted
|
||||
|
||||
|
||||
def add_floor(bpy, floor_key: str, floor: dict, materials: dict[str, object], spec: dict):
|
||||
z = float(floor["z"])
|
||||
height = float(floor.get("height", 4.2))
|
||||
config = spec.get("source", {}).get("config", {})
|
||||
bounds = floor["bounds"]
|
||||
margin = 1.2
|
||||
slab_thickness = float(floor.get("slab_thickness", config.get("slab_thickness", 0.25)))
|
||||
slab_box = [
|
||||
bounds[0] - margin,
|
||||
bounds[1] - margin,
|
||||
bounds[2] + margin,
|
||||
bounds[3] + margin,
|
||||
z - slab_thickness,
|
||||
z,
|
||||
]
|
||||
footprint = floor.get("footprint", {})
|
||||
footprint_polygons = footprint.get("polygons", []) if config.get("use_footprint_slabs", False) else []
|
||||
if footprint_polygons:
|
||||
create_polygon_prism_mesh(
|
||||
bpy,
|
||||
f"{floor_key}__slab",
|
||||
footprint_polygons,
|
||||
z - slab_thickness,
|
||||
z,
|
||||
materials["slab"],
|
||||
floor_key,
|
||||
"slab",
|
||||
)
|
||||
else:
|
||||
create_box_mesh(bpy, f"{floor_key}__slab", [slab_box], materials["slab"], floor_key, "slab")
|
||||
# Cap slabs close the tops of columns at setbacks and over basement parking
|
||||
# (computed by derive_showcase_spec.py and stored as floor["caps"]). They share
|
||||
# the slab category; Blender de-dups the object name and the Web viewer strips the suffix.
|
||||
for cap in floor.get("caps", []):
|
||||
cap_polys = cap.get("polygons", [])
|
||||
if not cap_polys:
|
||||
continue
|
||||
cap_z = float(cap.get("z", z + height))
|
||||
create_polygon_prism_mesh(
|
||||
bpy,
|
||||
f"{floor_key}__slab",
|
||||
cap_polys,
|
||||
cap_z - slab_thickness,
|
||||
cap_z,
|
||||
materials["slab"],
|
||||
floor_key,
|
||||
"slab",
|
||||
)
|
||||
floor_segments = floor.get("segments", {})
|
||||
known = [category for category in CATEGORY_DRAW_ORDER if floor_segments.get(category)]
|
||||
extra = sorted(category for category in floor_segments if category not in CATEGORY_DRAW_ORDER and floor_segments.get(category))
|
||||
for category in known + extra:
|
||||
segments = floor.get("segments", {}).get(category, [])
|
||||
if not segments:
|
||||
continue
|
||||
if category == "columns":
|
||||
segments = adjusted_column_segments(segments, floor_key, floor, spec)
|
||||
z0, z1 = z_window_for_category(category, z, height, floor_key, floor)
|
||||
create_segment_mesh(
|
||||
bpy,
|
||||
f"{floor_key}__{category}",
|
||||
segments,
|
||||
z0,
|
||||
z1,
|
||||
materials[category],
|
||||
floor_key,
|
||||
category,
|
||||
)
|
||||
if config.get("show_floor_labels", False):
|
||||
create_label(
|
||||
bpy,
|
||||
f"{floor_key}__label",
|
||||
floor.get("name", floor_key),
|
||||
(bounds[0], bounds[3] + 2.0, z + 0.08),
|
||||
1.8,
|
||||
materials["text"],
|
||||
)
|
||||
|
||||
|
||||
def scene_bounds(spec: dict) -> tuple[list[float], float]:
|
||||
bounds = [math.inf, math.inf, -math.inf, -math.inf]
|
||||
max_z = 0.0
|
||||
for floor in spec["floors"].values():
|
||||
b = floor["bounds"]
|
||||
bounds[0] = min(bounds[0], b[0])
|
||||
bounds[1] = min(bounds[1], b[1])
|
||||
bounds[2] = max(bounds[2], b[2])
|
||||
bounds[3] = max(bounds[3], b[3])
|
||||
max_z = max(max_z, float(floor["z"]) + float(floor.get("height", 4.2)))
|
||||
if not math.isfinite(bounds[0]):
|
||||
bounds = [0, 0, 1, 1]
|
||||
return bounds, max_z
|
||||
|
||||
|
||||
def add_generated_roofs(bpy, spec: dict, materials: dict[str, object]):
|
||||
for roof in generated_roof_bounds(spec):
|
||||
bounds = roof["bounds"]
|
||||
z = float(roof["z"])
|
||||
thickness = float(roof["thickness"])
|
||||
polygons = roof.get("polygons", [])
|
||||
if polygons:
|
||||
create_polygon_prism_mesh(
|
||||
bpy,
|
||||
f"{roof['floor_key']}__roof",
|
||||
polygons,
|
||||
z - thickness,
|
||||
z + 0.08,
|
||||
materials["roof"],
|
||||
str(roof["floor_key"]),
|
||||
"roof",
|
||||
)
|
||||
else:
|
||||
box = [bounds[0], bounds[1], bounds[2], bounds[3], z - thickness, z + 0.08]
|
||||
create_box_mesh(
|
||||
bpy,
|
||||
f"{roof['floor_key']}__roof",
|
||||
[box],
|
||||
materials["roof"],
|
||||
str(roof["floor_key"]),
|
||||
"roof",
|
||||
)
|
||||
|
||||
|
||||
def setup_scene(bpy, spec: dict):
|
||||
from mathutils import Vector
|
||||
|
||||
bpy.context.scene.unit_settings.system = "METRIC"
|
||||
bpy.context.scene.unit_settings.scale_length = 1.0
|
||||
try:
|
||||
bpy.context.scene.render.engine = "BLENDER_EEVEE"
|
||||
except TypeError:
|
||||
pass
|
||||
if bpy.context.scene.world:
|
||||
bpy.context.scene.world.color = (0.78, 0.82, 0.86)
|
||||
|
||||
category_defs = dict(spec.get("categories", {}))
|
||||
for floor in spec.get("floors", {}).values():
|
||||
for key in floor.get("segments", {}):
|
||||
category_defs.setdefault(key, {"color": DEFAULT_CATEGORY_COLORS.get(key, "#cccccc")})
|
||||
for key, color in DEFAULT_CATEGORY_COLORS.items():
|
||||
category_defs.setdefault(key, {"color": color})
|
||||
|
||||
alpha_by_category = {
|
||||
"slab": 0.72,
|
||||
"roof": 0.95,
|
||||
"glazing": 0.38,
|
||||
"floor_lines": 0.95,
|
||||
"grid": 0.95,
|
||||
"detail_lines": 0.82,
|
||||
"doors": 0.90,
|
||||
}
|
||||
materials = {
|
||||
key: make_material(
|
||||
bpy,
|
||||
key.replace("_", " "),
|
||||
category_defs.get(key, {}).get("color", DEFAULT_CATEGORY_COLORS.get(key, "#cccccc")),
|
||||
alpha_by_category.get(key, 1.0),
|
||||
)
|
||||
for key in category_defs
|
||||
}
|
||||
materials["text"] = make_material(bpy, "text", "#111111", 1.0)
|
||||
|
||||
for floor_key, floor in spec["floors"].items():
|
||||
add_floor(bpy, floor_key, floor, materials, spec)
|
||||
add_generated_roofs(bpy, spec, materials)
|
||||
|
||||
bounds, max_z = scene_bounds(spec)
|
||||
cx = (bounds[0] + bounds[2]) / 2.0
|
||||
cy = (bounds[1] + bounds[3]) / 2.0
|
||||
sx = max(bounds[2] - bounds[0], 1.0)
|
||||
sy = max(bounds[3] - bounds[1], 1.0)
|
||||
|
||||
bpy.ops.object.light_add(type="SUN", location=(0, 0, max_z + 30))
|
||||
sun = bpy.context.object
|
||||
sun.name = "Sun"
|
||||
sun.data.energy = 2.2
|
||||
sun.rotation_euler = (math.radians(45), 0, math.radians(35))
|
||||
|
||||
bpy.ops.object.light_add(type="AREA", location=(cx - sx * 0.25, cy - sy * 0.7, max_z + 40))
|
||||
area = bpy.context.object
|
||||
area.name = "Large softbox"
|
||||
area.data.energy = 600
|
||||
area.data.size = max(sx, sy) * 0.55
|
||||
|
||||
cam_distance = max(sx, sy, max_z) * 0.95
|
||||
bpy.ops.object.camera_add(location=(cx - cam_distance, cy - cam_distance * 0.85, max_z + cam_distance * 0.65))
|
||||
camera = bpy.context.object
|
||||
camera.name = "Camera - showcase overview"
|
||||
direction = Vector((cx, cy, max_z * 0.35)) - camera.location
|
||||
camera.rotation_euler = direction.to_track_quat("-Z", "Y").to_euler()
|
||||
camera.data.type = "ORTHO"
|
||||
camera.data.ortho_scale = max(sx, sy) * 1.18
|
||||
bpy.context.scene.camera = camera
|
||||
|
||||
bpy.context.scene.render.resolution_x = 1800
|
||||
bpy.context.scene.render.resolution_y = 1200
|
||||
bpy.context.scene.view_settings.view_transform = "Standard"
|
||||
bpy.context.scene.view_settings.look = "Medium High Contrast"
|
||||
return bounds, max_z
|
||||
|
||||
|
||||
def metadata(spec: dict, bounds: list[float], max_z: float, name: str) -> dict:
|
||||
config = spec.get("source", {}).get("config", {})
|
||||
return {
|
||||
"project": spec.get("project", {"name": name}),
|
||||
"floors": [
|
||||
{"key": key, "name": floor.get("name", key), "z": floor.get("z", 0), "height": floor.get("height", 4.2)}
|
||||
for key, floor in spec.get("floors", {}).items()
|
||||
],
|
||||
"categories": spec.get("categories", {}),
|
||||
"viewer_defaults": {
|
||||
"disabled_categories": list(config.get("default_disabled_categories", [])),
|
||||
},
|
||||
"bounds": {"xy": bounds, "max_z": max_z},
|
||||
"files": {"glb": f"{name}.glb", "blend": f"{name}.blend", "preview": f"{name}.png"},
|
||||
}
|
||||
|
||||
|
||||
def main() -> int:
|
||||
args = parse_args()
|
||||
try:
|
||||
import bpy # type: ignore
|
||||
except ImportError as exc:
|
||||
raise SystemExit("Run this script with Blender: blender -b --python build_blender_showcase.py -- --spec ...") from exc
|
||||
|
||||
spec_path = Path(args.spec)
|
||||
out_dir = Path(args.out_dir)
|
||||
out_dir.mkdir(parents=True, exist_ok=True)
|
||||
spec = json.loads(spec_path.read_text(encoding="utf-8"))
|
||||
clear_scene(bpy)
|
||||
bounds, max_z = setup_scene(bpy, spec)
|
||||
|
||||
blend_path = out_dir / f"{args.name}.blend"
|
||||
glb_path = out_dir / f"{args.name}.glb"
|
||||
png_path = out_dir / f"{args.name}.png"
|
||||
metadata_path = out_dir / "model_metadata.json"
|
||||
bpy.ops.wm.save_as_mainfile(filepath=str(blend_path))
|
||||
# Draco compression keeps the Web GLB lightweight (typically -85~92% size).
|
||||
# The Web template registers a DRACOLoader to decode it; keep both in sync.
|
||||
bpy.ops.export_scene.gltf(
|
||||
filepath=str(glb_path),
|
||||
export_format="GLB",
|
||||
export_draco_mesh_compression_enable=True,
|
||||
export_draco_mesh_compression_level=6,
|
||||
export_draco_position_quantization=14,
|
||||
export_draco_normal_quantization=10,
|
||||
export_draco_generic_quantization=12,
|
||||
)
|
||||
if args.render:
|
||||
bpy.context.scene.render.filepath = str(png_path)
|
||||
bpy.ops.render.render(write_still=True)
|
||||
metadata_path.write_text(json.dumps(metadata(spec, bounds, max_z, args.name), ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
print(json.dumps({
|
||||
"blend": str(blend_path),
|
||||
"glb": str(glb_path),
|
||||
"png": str(png_path),
|
||||
"metadata": str(metadata_path),
|
||||
"objects": len(bpy.data.objects),
|
||||
}, ensure_ascii=False))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user