Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

9.4 KB
Raw Blame
"""Render the compiled house GLB; no layout, furniture, or replacement meshes.

blender --background --factory-startup --python-exit-code 1 --python
  scripts/render-archviz-house.py -- house.glb output-directory [--preview]
Presentation owns shader detail, daylight and a disclosed overview cutaway.
All camera transforms, materials and physical geometry come from Firmament.
"""
import argparse
import hashlib
import json
import math
import sys
import time
from pathlib import Path

import bpy
from mathutils import Vector

parser = argparse.ArgumentParser()
parser.add_argument('source', type=Path)
parser.add_argument('output', type=Path)
parser.add_argument('--preview', action='store_true')
parser.add_argument('--view', choices=['Hero', 'Kitchen', 'Overview'])
args = parser.parse_args(sys.argv[sys.argv.index('--') + 1:])
args.output.mkdir(parents=True, exist_ok=True)
bpy.ops.wm.read_factory_settings(use_empty=True)
start = time.perf_counter()
bpy.ops.import_scene.gltf(filepath=str(args.source.resolve()))
scene = bpy.context.scene
products = [o for o in scene.objects if o.type == 'MESH']
cameras = {o.name: o for o in scene.objects if o.type == 'CAMERA'}
assert all(name in cameras for name in ('Hero', 'Kitchen', 'Overview'))
points = [o.matrix_world @ Vector(c) for o in products for c in o.bound_box]
lo = Vector([min(p[i] for p in points) for i in range(3)])
hi = Vector([max(p[i] for p in points) for i in range(3)])
assert all(o.matrix_world.determinant() > 0 for o in products)

def geometry_hash():
    result = hashlib.sha256()
    for obj in sorted(products, key=lambda o: o.name):
        result.update(obj.name.encode())
        for vertex in obj.data.vertices:
            result.update(str(tuple(vertex.co)).encode())
        for polygon in obj.data.polygons:
            result.update(str(tuple(polygon.vertices)).encode())
        result.update(str(tuple(tuple(row) for row in obj.matrix_world)).encode())
    return result.hexdigest()

before = geometry_hash()
for obj in products:
    if '.floor.panel' not in obj.name:
        continue
    for slot in obj.material_slots:
        if slot.material and slot.material.name.startswith('warmOak'):
            slot.material = slot.material.copy()
            slot.material.name = 'warmOak.floor'
for material in bpy.data.materials:
    if not material.use_nodes:
        continue
    nodes = material.node_tree.nodes
    links = material.node_tree.links
    bsdf = next((n for n in nodes if n.type == 'BSDF_PRINCIPLED'), None)
    if bsdf is None:
        continue
    name = material.name.split('.')[0]
    if name == 'clearGlass':
        # Portable authored opacity becomes an ordinary dielectric downstream.
        bsdf.inputs['Alpha'].default_value = 1
        bsdf.inputs['Transmission Weight'].default_value = 1
        bsdf.inputs['IOR'].default_value = 1.12
        bsdf.inputs['Base Color'].default_value = (.94, .98, .97, 1)
    if name in ('warmOak', 'creamFabric', 'linenRug'):
        tex = nodes.new('ShaderNodeTexNoise')
        mapping = nodes.new('ShaderNodeVectorMath')
        mapping.operation = 'MULTIPLY'
        coordinates = nodes.new('ShaderNodeTexCoord')
        mapping.inputs[1].default_value = (2, 85, 4) if name == 'warmOak' else (180, 180, 180)
        links.new(coordinates.outputs['Generated'], mapping.inputs[0])
        links.new(mapping.outputs[0], tex.inputs['Vector'])
        tex.inputs['Scale'].default_value = 2
        tex.inputs['Detail'].default_value = 2
        bump = nodes.new('ShaderNodeBump')
        bump.inputs['Strength'].default_value = .12 if name == 'warmOak' else .18
        bump.inputs['Distance'].default_value = .001 if name == 'warmOak' else .0006
        links.new(tex.outputs['Fac'], bump.inputs['Height'])
        links.new(bump.outputs['Normal'], bsdf.inputs['Normal'])
        if name == 'warmOak':
            ramp = nodes.new('ShaderNodeValToRGB')
            base = tuple(bsdf.inputs['Base Color'].default_value)
            ramp.color_ramp.elements[0].color = tuple(v * .72 for v in base[:3]) + (1,)
            ramp.color_ramp.elements[1].color = tuple(min(1, v * 1.17) for v in base[:3]) + (1,)
            links.new(tex.outputs['Fac'], ramp.inputs[0])
            links.new(ramp.outputs[0], bsdf.inputs['Base Color'])
        if material.name.startswith('warmOak.floor'):
            # A restrained board pattern is shader detail over the room slab.
            geometry = nodes.new('ShaderNodeNewGeometry')
            brick = nodes.new('ShaderNodeTexBrick')
            links.new(geometry.outputs['Position'], brick.inputs['Vector'])
            brick.inputs['Scale'].default_value = 1
            brick.inputs['Brick Width'].default_value = 1.6
            brick.inputs['Row Height'].default_value = .18
            brick.inputs['Mortar Size'].default_value = .002
            brick.inputs['Mortar Smooth'].default_value = .001
            brick.inputs['Color1'].default_value = (.41, .27, .135, 1)
            brick.inputs['Color2'].default_value = (.61, .42, .23, 1)
            brick.inputs['Mortar'].default_value = (.26, .17, .095, 1)
            links.new(brick.outputs['Color'], bsdf.inputs['Base Color'])

# Light fixtures are authored geometry; renderer lights derive from their diffusers.
def area(name, position, target, energy, size, color=(1, .87, .68)):
    data = bpy.data.lights.new(name, 'AREA')
    data.energy, data.size, data.color = energy, size, color
    obj = bpy.data.objects.new(name, data)
    scene.collection.objects.link(obj)
    obj.location = position
    obj.rotation_euler = (Vector(target) - obj.location).to_track_quat('-Z', 'Y').to_euler()
    return obj

centre = (lo + hi) / 2
for obj in products:
    if '.diffuser' in obj.name:
        p = sum((obj.matrix_world @ Vector(c) for c in obj.bound_box), Vector()) / 8
        area('Pendant illumination ' + obj.name, p - Vector((0, 0, .02)), p - Vector((0, 0, 1)), 55, .23)
    if obj.name.rsplit('.', 1)[-1] == 'pane':
        p = sum((obj.matrix_world @ Vector(c) for c in obj.bound_box), Vector()) / 8
        # Place daylight just inside each compiled aperture, aimed into its room.
        inward = Vector((centre.x - p.x, centre.y - p.y, 0)).normalized()
        area('Window daylight ' + obj.name, p + inward * .06, p + inward,
             650, 3.5, (1, .94, .82))
area('Soft ceiling bounce', (centre.x, centre.y, hi.z - .18), (centre.x, centre.y, 0), 160, 5)
scene.world = bpy.data.worlds.new('Warm daylight')
scene.world.use_nodes = True
scene.world.node_tree.nodes['Background'].inputs['Color'].default_value = (.78, .84, .87, 1)
scene.world.node_tree.nodes['Background'].inputs['Strength'].default_value = .45
sun_data = bpy.data.lights.new('Late afternoon', 'SUN')
sun_data.energy, sun_data.angle = .8, math.radians(12)
sun_data.color = (1, .87, .66)
sun = bpy.data.objects.new(sun_data.name, sun_data)
scene.collection.objects.link(sun)
sun.rotation_euler = (math.radians(32), math.radians(-24), math.radians(-35))

scene.render.engine = 'CYCLES'
scene.cycles.samples = 16 if args.preview else 80
scene.cycles.use_denoising = True
device = 'CPU'
try:
    preferences = bpy.context.preferences.addons['cycles'].preferences
    preferences.compute_device_type = 'OPTIX'
    preferences.get_devices()
    for available in preferences.devices:
        available.use = available.type == preferences.compute_device_type
    if any(d.use for d in preferences.devices):
        scene.cycles.device = 'GPU'
        device = ', '.join(d.name for d in preferences.devices if d.use)
except Exception:
    pass
scene.render.resolution_x = 960 if args.preview else 1920
scene.render.resolution_y = 600 if args.preview else 1200
scene.render.resolution_percentage = 100
scene.render.image_settings.file_format = 'PNG'
scene.view_settings.view_transform = 'AgX'
scene.view_settings.look = 'AgX - Medium High Contrast'
scene.view_settings.exposure = 0
timings = {}
hidden = []
for name in ([args.view] if args.view else ['Hero', 'Kitchen', 'Overview']):
    for obj in products:
        # Disclosed presentation cutaway. Full authored enclosure stays in USD/GLB.
        obj.hide_render = name == 'Overview' and any('.' + b + '.' in obj.name for b in ('ceiling', 'southWall', 'eastWall'))
    if name == 'Overview':
        hidden = [o.name for o in products if o.hide_render]
    scene.camera = cameras[name]
    scene.camera.data.clip_start = .01
    scene.camera.data.clip_end = 200
    scene.render.filepath = str((args.output / (name.lower() + '.png')).resolve())
    timer = time.perf_counter()
    bpy.ops.render.render(write_still=True)
    timings[name] = time.perf_counter() - timer
for obj in products:
    obj.hide_render = False
scene.camera = cameras['Hero']
assert geometry_hash() == before, 'Renderer changed compiled geometry'
bpy.ops.wm.save_as_mainfile(filepath=str((args.output / 'house.blend').resolve()))
report = dict(tool='Blender', version=bpy.app.version_string, device=device,
              sourceSha256=hashlib.sha256(args.source.read_bytes()).hexdigest(),
              geometryHash=before, geometryUnchanged=True,
              meshOccurrences=len(products), sharedMeshData=len({o.data.as_pointer() for o in products}),
              presentationLights=len([o for o in scene.objects if o.type == 'LIGHT']),
              boundsMetres=dict(min=list(lo), max=list(hi)), cameras=list(cameras),
              overviewHiddenBoundaries=hidden, renderSeconds=timings, totalSeconds=time.perf_counter() - start)
(args.output / 'blender-validation.json').write_text(json.dumps(report, indent=2) + '\n')
print(json.dumps(report))