gamesteel 0.2.0 → 0.3.1

package/dist/pkgs/model/blender/builder.py

@@ -0,0 +1,741 @@
+"""Gamesteel's builder (the Blender spec, "How it works", 4).
+
+Blender runs it in the background with a job, which is plain data in the
+model's frame: tiles, x to the right, y up, z to the front. The builder:
+
+- builds every part;
+- colours each part with its material, and lights it with the game's Style;
+- measures the model over every frame;
+- renders each frame to a PNG.
+
+It reads numbers and names from the job, and never evaluates any of it (R1).
+
+    blender --background --factory-startup --python-exit-code 1 \\
+        --python builder.py -- <job.json> <out folder>
+"""
+
+import json
+import math
+import os
+import sys
+import time
+
+import bmesh
+import bpy
+import numpy
+from mathutils import Matrix, Vector
+
+SIDES = 32
+RINGS = 16
+# Edges sharper than this are rounded by a part's rounding and drawn sharp.
+BEVEL_FROM = math.radians(40)
+SHARP = math.radians(35)
+# Roughness and metal for each kind; shine overrides the roughness.
+# Metal is half metallic: fully, it would only mirror the sky's fill colour and
+# lose its own palette colour (tuned by eye, the plan's Task 10).
+KINDS = {
+    'painted': (0.5, 0.0), 'metal': (0.3, 0.45), 'plastic': (0.22, 0.0), 'rubber': (0.85, 0.0),
+    'cloth': (0.95, 0.0), 'leather': (0.55, 0.0), 'skin': (0.6, 0.0), 'wood': (0.7, 0.0),
+    'stone': (0.85, 0.0), 'glass': (0.06, 0.0), 'glow': (1.0, 0.0),
+}
+SHINY = {'metal', 'plastic', 'glass'}
+
+
+def linear(c):
+    """An sRGB colour, 0 to 1, as Blender's linear light."""
+    return tuple(v / 12.92 if v <= 0.04045 else ((v + 0.055) / 1.055) ** 2.4 for v in c)
+
+
+def link(ob, collection=None):
+    (collection or bpy.context.scene.collection).objects.link(ob)
+    return ob
+
+
+def empty(name, parent=None):
+    ob = link(bpy.data.objects.new(name, None))
+    ob.parent = parent
+    ob.rotation_mode = 'QUATERNION'
+    return ob
+
+
+def place(ob, t):
+    ob.location = t['position']
+    ob.rotation_quaternion = t['rotation']
+    ob.scale = t['scale']
+
+
+# Shapes, each built in the model's frame, y up, centred as the kit says.
+
+def lift(bm):
+    """bmesh makes round things along z; the model's up is y."""
+    bmesh.ops.rotate(bm, verts=bm.verts, cent=(0, 0, 0), matrix=Matrix.Rotation(math.radians(-90), 3, 'X'))
+
+
+def make_box(s):
+    bm = bmesh.new()
+    bmesh.ops.create_cube(bm, size=1.0)
+    bmesh.ops.scale(bm, vec=(s['w'], s['h'], s['d']), verts=bm.verts)
+    return bm
+
+
+def make_ball(s):
+    bm = bmesh.new()
+    bmesh.ops.create_uvsphere(bm, u_segments=SIDES, v_segments=RINGS, radius=s['r'])
+    lift(bm)
+    return bm
+
+
+def make_egg(s):
+    bm = bmesh.new()
+    bmesh.ops.create_uvsphere(bm, u_segments=SIDES, v_segments=RINGS, radius=0.5)
+    lift(bm)
+    bmesh.ops.scale(bm, vec=(s['w'], s['h'], s['d']), verts=bm.verts)
+    return bm
+
+
+def make_cone(s, top=None):
+    bm = bmesh.new()
+    bmesh.ops.create_cone(bm, cap_ends=True, cap_tris=False, segments=SIDES, radius1=s['r'],
+                          radius2=s['top'] if top is None else top, depth=s['h'])
+    bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-6)
+    lift(bm)
+    return bm
+
+
+def make_cylinder(s):
+    return make_cone(s, s['r'])
+
+
+def make_lathe(profile):
+    bm = bmesh.new()
+    verts = [bm.verts.new((r, h, 0.0)) for r, h in profile]
+    edges = [bm.edges.new((verts[i], verts[i + 1])) for i in range(len(verts) - 1)]
+    bmesh.ops.spin(bm, geom=verts + edges, cent=(0, 0, 0), axis=(0, 1, 0), angle=2 * math.pi,
+                   steps=SIDES, use_duplicate=False)
+    bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-5)
+    open_edges = [e for e in bm.edges if e.is_boundary]
+    if open_edges:
+        bmesh.ops.holes_fill(bm, edges=open_edges, sides=0)
+    return bm
+
+
+def make_capsule(s):
+    r, h, arc = s['r'], s['h'], 8
+    low = [(r * math.cos(math.radians(-90 + 90 * i / arc)), -h / 2 + r + r * math.sin(math.radians(-90 + 90 * i / arc)))
+           for i in range(arc + 1)]
+    high = [(r * math.cos(math.radians(90 * i / arc)), h / 2 - r + r * math.sin(math.radians(90 * i / arc)))
+            for i in range(arc + 1)]
+    return make_lathe(low + high)
+
+
+def make_torus(s):
+    bm = bmesh.new()
+    big, small, rings = s['r'], s['thickness'] / 2, []
+    for i in range(SIDES):
+        a = 2 * math.pi * i / SIDES
+        ring = []
+        for j in range(12):
+            b = 2 * math.pi * j / 12
+            reach = big + small * math.cos(b)
+            ring.append(bm.verts.new((reach * math.cos(a), small * math.sin(b), reach * math.sin(a))))
+        rings.append(ring)
+    for i in range(SIDES):
+        a, b = rings[i], rings[(i + 1) % SIDES]
+        for j in range(12):
+            bm.faces.new((a[j], a[(j + 1) % 12], b[(j + 1) % 12], b[j]))
+    return bm
+
+
+def make_dome(s):
+    bm = make_ball(s)
+    geom = bm.verts[:] + bm.edges[:] + bm.faces[:]
+    bmesh.ops.bisect_plane(bm, geom=geom, dist=1e-6, plane_co=(0, 0, 0), plane_no=(0, 1, 0), clear_inner=True)
+    open_edges = [e for e in bm.edges if e.is_boundary]
+    if open_edges:
+        bmesh.ops.holes_fill(bm, edges=open_edges, sides=0)
+    return bm
+
+
+def make_wedge(s):
+    w, h, d = s['w'] / 2, s['h'] / 2, s['d'] / 2
+    bm = bmesh.new()
+    v = [bm.verts.new(p) for p in [(-w, -h, -d), (w, -h, -d), (w, h, -d), (-w, h, -d), (-w, -h, d), (w, -h, d)]]
+    for face in [(0, 1, 2, 3), (4, 5, 1, 0), (3, 2, 5, 4), (0, 3, 4), (1, 5, 2)]:
+        bm.faces.new([v[i] for i in face])
+    return bm
+
+
+def make_tube(s):
+    curve = bpy.data.curves.new('gm-tube', 'CURVE')
+    curve.dimensions = '3D'
+    curve.bevel_depth = 1.0
+    curve.bevel_resolution = 4
+    curve.use_fill_caps = True
+    curve.resolution_u = 8
+    path = s['path']
+    radii = s['radius'] if len(s['radius']) == len(path) else [s['radius'][0]] * len(path)
+    spline = curve.splines.new('NURBS' if len(path) > 2 else 'POLY')
+    spline.points.add(len(path) - 1)
+    for point, at, r in zip(spline.points, path, radii):
+        point.co = (at[0], at[1], at[2], 1.0)
+        point.radius = r
+    if spline.type == 'NURBS':
+        spline.use_endpoint_u = True
+        spline.order_u = 3
+    ob = link(bpy.data.objects.new('gm-tube', curve))
+    mesh = bpy.data.meshes.new_from_object(ob.evaluated_get(bpy.context.evaluated_depsgraph_get()))
+    bpy.data.objects.remove(ob)
+    bpy.data.curves.remove(curve)
+    bm = bmesh.new()
+    bm.from_mesh(mesh)
+    bpy.data.meshes.remove(mesh)
+    return bm
+
+
+def make_slab(s):
+    t = s['thickness'] / 2
+    bm = bmesh.new()
+    face = bm.faces.new([bm.verts.new((x, y, t)) for x, y in s['outline']])
+    made = bmesh.ops.extrude_face_region(bm, geom=[face])
+    moved = [e for e in made['geom'] if isinstance(e, bmesh.types.BMVert)]
+    bmesh.ops.translate(bm, verts=moved, vec=(0, 0, -2 * t))
+    return bm
+
+
+def resample(outline, n):
+    """An outline as n points evenly along it, from its first point round."""
+    points = [Vector(p) for p in outline] + [Vector(outline[0])]
+    lengths = [(points[i + 1] - points[i]).length for i in range(len(points) - 1)]
+    total = sum(lengths) or 1.0
+    out = []
+    for k in range(n):
+        d, i = total * k / n, 0
+        while i < len(lengths) - 1 and d > lengths[i]:
+            d -= lengths[i]
+            i += 1
+        t = 0.0 if lengths[i] == 0 else min(1.0, d / lengths[i])
+        out.append(points[i].lerp(points[i + 1], t))
+    return out
+
+
+def make_loft(s):
+    sections = s['sections']
+    counts = {len(sec['outline']) for sec in sections}
+    # Outlines of one count keep their corners; others are spaced evenly.
+    n = counts.pop() if len(counts) == 1 else max(len(sec['outline']) for sec in sections)
+    same = all(len(sec['outline']) == n for sec in sections)
+    bm = bmesh.new()
+    loops = []
+    for sec in sections:
+        points = [Vector(p) for p in sec['outline']] if same else resample(sec['outline'], n)
+        loops.append([bm.verts.new((p.x, p.y, sec['z'])) for p in points])
+    for a, b in zip(loops, loops[1:]):
+        for k in range(n):
+            bm.faces.new((a[k], a[(k + 1) % n], b[(k + 1) % n], b[k]))
+    bm.faces.new(loops[0])
+    bm.faces.new(loops[-1])
+    return bm
+
+
+MAKERS = {
+    'box': make_box, 'ball': make_ball, 'egg': make_egg, 'capsule': make_capsule, 'cylinder': make_cylinder,
+    'cone': make_cone, 'torus': make_torus, 'dome': make_dome, 'wedge': make_wedge,
+    'lathe': lambda s: make_lathe(s['profile']), 'tube': make_tube, 'slab': make_slab, 'loft': make_loft,
+}
+
+
+def finish(bm, rounding):
+    """Normals out, sharp edges rounded and kept sharp, and each vertex's
+    convexity kept as gm_edge, where wear rubs."""
+    bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
+    if rounding > 0:
+        sharp = [e for e in bm.edges if len(e.link_faces) == 2 and e.calc_face_angle(0.0) > BEVEL_FROM]
+        if sharp:
+            bmesh.ops.bevel(bm, geom=sharp, offset=rounding, offset_type='OFFSET', segments=3, profile=0.5,
+                            affect='EDGES', clamp_overlap=True)
+    for f in bm.faces:
+        f.smooth = True
+    for e in bm.edges:
+        if len(e.link_faces) != 2 or e.calc_face_angle(0.0) > SHARP:
+            e.smooth = False
+    layer = bm.verts.layers.float.new('gm_edge')
+    for v in bm.verts:
+        convex = max([e.calc_face_angle_signed(0.0) for e in v.link_edges if len(e.link_faces) == 2] + [0.0])
+        v[layer] = max(0.0, min(1.0, convex / 1.2))
+
+
+class Graph:
+    """A material's nodes, made by calls; each call answers the socket it outputs."""
+
+    def __init__(self, material):
+        self.tree = material.node_tree
+        self.tree.nodes.clear()
+
+    def node(self, kind, **settings):
+        n = self.tree.nodes.new(kind)
+        for key, value in settings.items():
+            setattr(n, key, value)
+        return n
+
+    def feed(self, socket, value):
+        if isinstance(value, (int, float, tuple)):
+            socket.default_value = value
+        else:
+            self.tree.links.new(value, socket)
+
+    def math(self, op, a, b=0.0, clamp=False):
+        n = self.node('ShaderNodeMath', operation=op, use_clamp=clamp)
+        self.feed(n.inputs[0], a)
+        self.feed(n.inputs[1], b)
+        return n.outputs[0]
+
+    def colour(self, rgb):
+        n = self.node('ShaderNodeRGB')
+        n.outputs[0].default_value = linear(rgb) + (1.0,)
+        return n.outputs[0]
+
+    def mix(self, blend, fac, a, b):
+        # By position: Blender 5 renamed some sockets (Fac is Factor).
+        n = self.node('ShaderNodeMixRGB', blend_type=blend, use_clamp=True)
+        self.feed(n.inputs[0], fac)
+        self.feed(n.inputs[1], a)
+        self.feed(n.inputs[2], b)
+        return n.outputs[0]
+
+    def split(self, vector):
+        n = self.node('ShaderNodeSeparateXYZ')
+        self.feed(n.inputs[0], vector)
+        return n.outputs[0], n.outputs[1], n.outputs[2]
+
+    def scaled(self, vector, k):
+        n = self.node('ShaderNodeVectorMath', operation='SCALE')
+        self.feed(n.inputs[0], vector)
+        n.inputs['Scale'].default_value = k
+        return n.outputs[0]
+
+    def noise(self, vector, scale, detail=2.0):
+        n = self.node('ShaderNodeTexNoise')
+        self.feed(n.inputs['Vector'], vector)
+        n.inputs['Scale'].default_value = scale
+        n.inputs['Detail'].default_value = detail
+        return n.outputs[0]
+
+    def voronoi(self, vector, scale, feature='F1'):
+        n = self.node('ShaderNodeTexVoronoi', feature=feature)
+        self.feed(n.inputs['Vector'], vector)
+        n.inputs['Scale'].default_value = scale
+        return n
+
+    def to_grid(self, u):
+        """How far u is from the nearest whole number, 0 to 0.5."""
+        return self.math('ABSOLUTE', self.math('SUBTRACT', self.math('FRACT', self.math('ADD', u, 0.5)), 0.5))
+
+    def triplanar(self, point, normal, plane):
+        """plane(u, v) on each of the three planes, blended by which way the surface faces."""
+        x, y, z = self.split(point)
+        nx, ny, nz = self.split(normal)
+        weights = [self.math('POWER', self.math('ABSOLUTE', c), 4.0) for c in (nx, ny, nz)]
+        total = self.math('ADD', self.math('ADD', weights[0], weights[1]), self.math('ADD', weights[2], 1e-6))
+        out = None
+        for w, face in zip(weights, (plane(y, z), plane(x, z), plane(x, y))):
+            part = self.math('MULTIPLY', self.math('DIVIDE', w, total), face)
+            out = part if out is None else self.math('ADD', out, part)
+        return out
+
+
+class Builder:
+    def __init__(self, job, out):
+        self.job = job
+        self.out = out
+        self.objects = {}
+        self.rest = {}
+        self.materials = {}
+
+    def run(self):
+        self.setup()
+        for m in self.job['materials']:
+            self.materials[m['id']] = (self.material(m), m)
+        for o in self.job['objects']:
+            self.make(o)
+        for o in self.job['objects']:
+            for cutter in o['cuts']:
+                self.objects[o['id']].modifiers['cut-%d' % cutter].object = self.objects[cutter]
+        self.lights()
+        self.outline()
+        frame = self.measure()
+        if frame is None:
+            return {'ok': False, 'reason': 'nothing in the model is drawn'}
+        if frame == 'cut':
+            return {'ok': False, 'reason': 'nothing in the model is drawn: its cuts take all of it'}
+        self.camera(frame)
+        for i, f in enumerate(self.job['frames']):
+            self.pose(f)
+            self.scene.render.filepath = os.path.join(self.out, 'frame-%03d.png' % i)
+            bpy.ops.render.render(write_still=True)
+        return {
+            'ok': True, 'frame': {'w': frame['w'], 'h': frame['h']}, 'pixelsPerTile': frame['ppt'],
+            'extent': {'half': frame['half'], 'bottom': frame['bottom'], 'top': frame['top']},
+        }
+
+    def setup(self):
+        bpy.ops.wm.read_factory_settings(use_empty=True)
+        s = self.scene = bpy.context.scene
+        engines = [i.identifier for i in bpy.types.RenderSettings.bl_rna.properties['engine'].enum_items]
+        s.render.engine = 'BLENDER_EEVEE_NEXT' if 'BLENDER_EEVEE_NEXT' in engines else 'BLENDER_EEVEE'
+        pixel = self.job['style']['pixel']
+        s.eevee.taa_render_samples = 1 if pixel else 16
+        s.render.film_transparent = True
+        s.render.resolution_percentage = 100
+        # Exact colours, crisp edges: no dither noise on 8-bit output, and a
+        # tighter filter than Blender's 1.5 px, so a sprite is not soft.
+        s.render.dither_intensity = 0.0
+        s.render.filter_size = 1.0
+        s.render.image_settings.file_format = 'PNG'
+        s.render.image_settings.color_mode = 'RGBA'
+        s.render.image_settings.color_depth = '8'
+        # Standard, so a palette colour renders as it is set (R3).
+        s.view_settings.view_transform = 'Standard'
+        s.view_settings.look = 'None'
+        s.view_settings.exposure = 0.0
+        s.view_settings.gamma = 1.0
+        # The model's frame in Blender's: its y up is Blender's z, its front faces the camera.
+        kit = empty('gm-kit')
+        kit.rotation_mode = 'XYZ'
+        kit.rotation_euler = (math.radians(90), 0, 0)
+        view = empty('gm-view', kit)
+        turn, tilt = self.job['view']['turn'], self.job['view']['tilt']
+        view.rotation_quaternion = (Matrix.Rotation(math.radians(tilt), 4, 'X') @ Matrix.Rotation(math.radians(turn), 4, 'Y')).to_quaternion()
+        self.model = empty('gm-model', view)
+        self.unlined = bpy.data.collections.new('gm-unlined')
+        s.collection.children.link(self.unlined)
+
+    def make(self, o):
+        shape = o['shape']
+        parent = self.model if o['parent'] is None else self.objects[o['parent']]
+        if shape['kind'] == 'group':
+            ob = empty(o['name'], parent)
+        else:
+            bm = MAKERS[shape['kind']](shape)
+            finish(bm, o['round'])
+            mesh = bpy.data.meshes.new(o['name'])
+            bm.to_mesh(mesh)
+            bm.free()
+            ob = link(bpy.data.objects.new(o['name'], mesh))
+            ob.parent = parent
+            ob.rotation_mode = 'QUATERNION'
+            material, spec = self.materials[o['material']]
+            mesh.materials.append(material)
+            for cutter in o['cuts']:
+                cut = ob.modifiers.new('cut-%d' % cutter, 'BOOLEAN')
+                cut.operation = 'DIFFERENCE'
+                cut.solver = 'EXACT'
+            if o['smooth'] > 0:
+                sub = ob.modifiers.new('smooth', 'SUBSURF')
+                sub.levels = o['smooth']
+                sub.render_levels = o['smooth']
+            if o['cutter']:
+                ob.hide_render = True
+                ob.display_type = 'WIRE'
+            elif spec['kind'] == 'glow':
+                self.unlined.objects.link(ob)
+        place(ob, o['rest'])
+        self.objects[o['id']] = ob
+        self.rest[o['id']] = o['rest']
+
+    def material(self, m):
+        mat = bpy.data.materials.new('gm-%d' % m['id'])
+        mat.use_nodes = True
+        g = Graph(mat)
+        d = m['detail']
+        shading = self.job['style']['shading']
+        coords = g.node('ShaderNodeTexCoord')
+        point, normal = coords.outputs['Object'], coords.outputs['Normal']
+        model = g.node('ShaderNodeTexCoord')
+        model.object = self.model
+        roughness, metal = KINDS[m['kind']]
+        if d['shine'] is not None:
+            roughness = 1.0 - d['shine']
+        shiny = m['kind'] in SHINY or (d['shine'] is not None and d['shine'] >= 0.6)
+        col = g.colour(m['colour'])
+        rough = roughness
+        height = None
+
+        def bump(h):
+            nonlocal height
+            height = h if height is None else g.math('ADD', height, h)
+
+        if d['stripes'] is not None:
+            st = d['stripes']
+            _, gy, _ = g.split(coords.outputs['Generated'])
+            band = g.math('LESS_THAN', g.math('FRACT', g.math('MULTIPLY', gy, st['count'])), st['width'])
+            col = g.mix('MIX', band, col, g.colour(st['colour']))
+        if d['spots'] is not None:
+            sp = d['spots']
+            cells = g.voronoi(point, 1.0 / sp['size'])
+            pick = g.math('LESS_THAN', g.split(cells.outputs['Color'])[0], sp['amount'])
+            spot = g.math('MULTIPLY', pick, g.math('LESS_THAN', cells.outputs['Distance'], 0.32))
+            col = g.mix('MIX', spot, col, g.colour(sp['colour']))
+        seam = None
+        if d['panels'] > 0 or d['stitches'] > 0:
+            n = d['panels'] if d['panels'] > 0 else 2.0
+            seam = g.triplanar(g.scaled(point, n), normal, lambda u, v: g.math('MINIMUM', g.to_grid(u), g.to_grid(v)))
+        if d['panels'] > 0:
+            line = g.math('LESS_THAN', seam, 0.035)
+            col = g.mix('MULTIPLY', g.math('MULTIPLY', line, 0.45), col, (0.0, 0.0, 0.0, 1.0))
+            bump(g.math('MULTIPLY', line, -0.4))
+            if d['rivets'] > 0:
+                def dots(u, v):
+                    gu, gv = g.to_grid(u), g.to_grid(v)
+                    return g.math('SQRT', g.math('ADD', g.math('MULTIPLY', gu, gu), g.math('MULTIPLY', gv, gv)))
+                dot = g.triplanar(g.scaled(point, d['panels'] * 6), normal, dots)
+                near = g.math('MULTIPLY', g.math('LESS_THAN', seam, 0.12), g.math('GREATER_THAN', seam, 0.05))
+                rivet = g.math('MULTIPLY', g.math('MULTIPLY', g.math('LESS_THAN', dot, 0.16), near), d['rivets'])
+                col = g.mix('SCREEN', g.math('MULTIPLY', rivet, 0.5), col, (1.0, 1.0, 1.0, 1.0))
+                bump(g.math('MULTIPLY', rivet, 0.5))
+        if d['stitches'] > 0:
+            band = g.math('MULTIPLY', g.math('LESS_THAN', seam, 0.08), g.math('GREATER_THAN', seam, 0.045))
+            dash = g.math('GREATER_THAN', g.noise(g.scaled(point, 1.0), 60.0, 0.0), 0.5)
+            stitch = g.math('MULTIPLY', g.math('MULTIPLY', band, dash), d['stitches'])
+            col = g.mix('SCREEN', g.math('MULTIPLY', stitch, 0.6), col, (1.0, 1.0, 1.0, 1.0))
+        if d['grain'] > 0:
+            wave = g.node('ShaderNodeTexWave', wave_type='BANDS', bands_direction='Y')
+            g.feed(wave.inputs['Vector'], point)
+            wave.inputs['Scale'].default_value = 6.0
+            wave.inputs['Distortion'].default_value = 6.0
+            col = g.mix('MULTIPLY', g.math('MULTIPLY', wave.outputs[1], d['grain'] * 0.5), col, (0.62, 0.55, 0.5, 1.0))
+        if d['cracks'] > 0:
+            edges = g.voronoi(point, 5.0, 'DISTANCE_TO_EDGE')
+            crack = g.math('MULTIPLY', g.math('LESS_THAN', edges.outputs['Distance'], 0.035), d['cracks'])
+            col = g.mix('MULTIPLY', crack, col, (0.35, 0.33, 0.33, 1.0))
+            bump(g.math('MULTIPLY', crack, -0.5))
+        if d['rust'] > 0:
+            patch = g.math('MULTIPLY', g.math('SUBTRACT', g.noise(point, 3.5, 6.0), 1.0 - d['rust']), 4.0, clamp=True)
+            col = g.mix('MIX', patch, col, g.colour((0.48, 0.24, 0.11)))
+            rough = g.math('ADD', rough, g.math('MULTIPLY', patch, 0.3))
+        if d['grime'] > 0:
+            span = self.job['span']
+            low = g.node('ShaderNodeMapRange', clamp=True)
+            g.feed(low.inputs['Value'], g.split(model.outputs['Object'])[1])
+            low.inputs['From Min'].default_value = span['low']
+            low.inputs['From Max'].default_value = span['high'] if span['high'] > span['low'] else span['low'] + 1.0
+            low.inputs['To Min'].default_value = 1.0
+            low.inputs['To Max'].default_value = 0.0
+            dirt = g.math('MULTIPLY', g.math('MULTIPLY', low.outputs['Result'], g.math('ADD', g.noise(point, 4.0), 0.5)), d['grime'] * 1.6, clamp=True)
+            col = g.mix('MULTIPLY', dirt, col, (0.33, 0.29, 0.25, 1.0))
+        if d['scratches'] > 0:
+            scratch = g.math('MULTIPLY', g.math('GREATER_THAN', g.noise(point, 38.0, 8.0), 0.66), d['scratches'] * 0.8)
+            col = g.mix('SCREEN', scratch, col, (0.7, 0.7, 0.7, 1.0))
+        if d['wear'] > 0:
+            edge = g.node('ShaderNodeAttribute', attribute_name='gm_edge').outputs[2]
+            worn = g.math('MULTIPLY', g.math('MULTIPLY', edge, g.math('ADD', g.noise(point, 9.0), 0.4)), d['wear'] * 2.2, clamp=True)
+            col = g.mix('MIX', worn, col, g.mix('MIX', 0.55, col, (0.85, 0.85, 0.85, 1.0)))
+            rough = g.math('SUBTRACT', rough, g.math('MULTIPLY', worn, 0.25))
+        if d['dents'] > 0:
+            bump(g.math('MULTIPLY', g.voronoi(point, 7.0, 'SMOOTH_F1').outputs['Distance'], d['dents'] * 0.6))
+        if d['bumps'] > 0:
+            bump(g.math('MULTIPLY', g.noise(point, 22.0, 4.0), d['bumps'] * 0.35))
+
+        out = g.node('ShaderNodeOutputMaterial')
+        if m['kind'] == 'glow':
+            emit = g.node('ShaderNodeEmission')
+            g.feed(emit.inputs[0], col)
+            emit.inputs[1].default_value = 1.0 + 2.0 * d['glow']
+            g.feed(out.inputs['Surface'], emit.outputs[0])
+            return mat
+        surface = g.node('ShaderNodeBsdfPrincipled')
+        g.feed(surface.inputs['Roughness'], rough)
+        if height is not None:
+            relief = g.node('ShaderNodeBump')
+            relief.inputs['Strength'].default_value = 0.35 if shading == 'soft' else 0.15
+            g.feed(relief.inputs['Height'], height)
+            g.feed(surface.inputs['Normal'], relief.outputs['Normal'])
+        if shading == 'soft':
+            g.feed(surface.inputs['Base Color'], col if m['kind'] != 'glass' else g.mix('MULTIPLY', 0.4, col, (0.0, 0.0, 0.0, 1.0)))
+            surface.inputs['Metallic'].default_value = metal
+            if m['kind'] == 'glass':
+                surface.inputs['Coat Weight'].default_value = 1.0
+            if d['glow'] > 0:
+                g.feed(surface.inputs['Emission Color'], col)
+                surface.inputs['Emission Strength'].default_value = 2.0 * d['glow']
+            g.feed(out.inputs['Surface'], surface.outputs[0])
+            return mat
+        # Cel shading: the light on white, in bands, times the colour (R4).
+        surface.inputs['Base Color'].default_value = (1.0, 1.0, 1.0, 1.0)
+        surface.inputs['Specular IOR Level'].default_value = 0.5 if shiny else 0.0
+        lit = g.node('ShaderNodeShaderToRGB')
+        g.feed(lit.inputs[0], surface.outputs[0])
+        ramp = g.node('ShaderNodeValToRGB')
+        ramp.color_ramp.interpolation = 'CONSTANT'
+        bands = [(0.0, (0.58, 0.6, 0.7)), (0.2, (1.0, 1.0, 1.0))] if shading == 'flat' else \
+            [(0.0, (0.5, 0.52, 0.62)), (0.15, (0.76, 0.77, 0.84)), (0.5, (1.0, 1.0, 1.0))]
+        if shiny:
+            bands.append((0.92, (1.3, 1.3, 1.3)))
+        elements = ramp.color_ramp.elements
+        while len(elements) < len(bands):
+            elements.new(0.99)
+        for element, (at, tone) in zip(elements, bands):
+            element.position = at
+            element.color = tone + (1.0,)
+        g.feed(ramp.inputs[0], lit.outputs[0])
+        toned = g.mix('MULTIPLY', 1.0, col, ramp.outputs[0])
+        if d['glow'] > 0:
+            toned = g.mix('ADD', d['glow'], toned, col)
+        emit = g.node('ShaderNodeEmission')
+        g.feed(emit.inputs[0], toned)
+        emit.inputs[1].default_value = 1.0
+        g.feed(out.inputs['Surface'], emit.outputs[0])
+        return mat
+
+    def lights(self):
+        style = self.job['style']
+        theta = math.radians(style['light'])
+        # From where the Style says on screen, a little toward the camera, so fronts are lit.
+        toward = Vector((math.sin(theta), -0.8, math.cos(theta))).normalized()
+        sun = bpy.data.lights.new('gm-sun', 'SUN')
+        sun.energy = 3.0 if style['shading'] == 'soft' else 3.2
+        sun.angle = math.radians(4)
+        ob = link(bpy.data.objects.new('gm-sun', sun))
+        ob.rotation_mode = 'QUATERNION'
+        ob.rotation_quaternion = toward.to_track_quat('Z', 'Y')
+        world = bpy.data.worlds.new('gm-world')
+        world.use_nodes = True
+        self.scene.world = world
+        background = world.node_tree.nodes['Background']
+        sky = [(a + b) / 2 for a, b in zip(style['sky']['top'], style['sky']['horizon'])]
+        background.inputs['Color'].default_value = linear(sky) + (1.0,)
+        background.inputs['Strength'].default_value = 0.55 if style['shading'] == 'soft' else 0.0
+
+    def outline(self):
+        line = self.job['style']['outline']
+        render = self.scene.render
+        render.use_freestyle = line is not None
+        if line is None:
+            return
+        render.line_thickness_mode = 'ABSOLUTE'
+        settings = bpy.context.view_layer.freestyle_settings
+        settings.crease_angle = math.radians(134)
+        lines = settings.linesets[0] if len(settings.linesets) > 0 else settings.linesets.new('gm-lines')
+        lines.select_by_visibility = True
+        lines.select_by_edge_types = True
+        lines.select_silhouette = True
+        lines.select_border = True
+        lines.select_crease = True
+        lines.select_external_contour = True
+        # Glowing parts carry no outline.
+        lines.select_by_collection = True
+        lines.collection = self.unlined
+        lines.collection_negation = 'EXCLUSIVE'
+        if lines.linestyle is None:
+            lines.linestyle = bpy.data.linestyles.new('gm-line')
+        lines.linestyle.color = linear(line['colour'])
+        lines.linestyle.thickness = line['px']
+
+    def pose(self, frame):
+        place(self.model, frame['model'])
+        for key, ob in self.objects.items():
+            place(ob, frame['objects'].get(str(key), self.rest[key]))
+        if frame.get('grounded'):
+            self.ground()
+
+    def ground(self):
+        """Its lowest drawn point on the ground line, measured on the shapes as
+        built, after rounding, smoothing and cuts (phase 2, R2). In a tilted view a
+        foot further back is drawn higher, so the drawn point is the one that stands
+        (the final review); seen from the top, the lowest point in the model's frame."""
+        bpy.context.view_layer.update()
+        graph = bpy.context.evaluated_depsgraph_get()
+        # How far a step up the model's y moves it up the picture: 1 untilted, 0 from the top.
+        rise = (self.model.parent.matrix_world.to_3x3() @ Vector((0.0, 1.0, 0.0))).z
+        flat = rise < 0.05
+        to_ground = self.model.parent.matrix_world.inverted() if flat else Matrix.Identity(4)
+        row = 1 if flat else 2
+        low = math.inf
+        for ob in self.objects.values():
+            if ob.type != 'MESH' or ob.hide_render:
+                continue
+            seen = ob.evaluated_get(graph)
+            count = len(seen.data.vertices)
+            if count == 0:
+                continue
+            co = numpy.empty(count * 3, dtype=numpy.float32)
+            seen.data.vertices.foreach_get('co', co)
+            m = numpy.array(to_ground @ seen.matrix_world, dtype=numpy.float64)
+            ys = co.reshape(count, 3).astype(numpy.float64) @ m[row, :3] + m[row, 3]
+            low = min(low, float(ys.min()))
+        if low < math.inf:
+            self.model.location.y -= low if flat else low / rise
+
+    def measure(self):
+        """The model's extent over every frame, as the camera sees it, and the frame that holds it:
+        None with nothing to draw, 'cut' when its cuts take all of it."""
+        shown = [ob for ob in self.objects.values() if ob.type == 'MESH' and not ob.hide_render]
+        if not shown:
+            return None
+        left = bottom = math.inf
+        right = top = -math.inf
+        drawn = False
+        for frame in self.job['frames']:
+            self.pose(frame)
+            bpy.context.view_layer.update()
+            graph = bpy.context.evaluated_depsgraph_get()
+            for ob in shown:
+                seen = ob.evaluated_get(graph)
+                # A part its cuts take all of has no surface left, and its box is
+                # a point at its origin: it is not drawn (the final review).
+                if len(seen.data.vertices) == 0:
+                    continue
+                drawn = True
+                for corner in seen.bound_box:
+                    at = seen.matrix_world @ Vector(corner)
+                    left, right = min(left, at.x), max(right, at.x)
+                    bottom, top = min(bottom, at.z), max(top, at.z)
+        if not drawn:
+            return 'cut'
+        ppt = self.job['pixelsPerTile']
+        while True:
+            margin = self.job['marginPx'] / ppt
+            half = max(abs(left), abs(right)) + margin
+            low = min(0.0, bottom) - margin
+            high = top + margin
+            w, h = math.ceil(2 * half * ppt), math.ceil((high - low) * ppt)
+            if (w <= self.job['maxFrame'] and h <= self.job['maxFrame']) or ppt <= 4:
+                return {'w': max(1, w), 'h': max(1, h), 'ppt': ppt, 'half': w / (2 * ppt), 'bottom': low, 'top': low + h / ppt}
+            ppt -= 1
+
+    def camera(self, frame):
+        cam = bpy.data.cameras.new('gm-camera')
+        cam.type = 'ORTHO'
+        cam.ortho_scale = max(frame['w'], frame['h']) / frame['ppt']
+        cam.clip_start = 0.01
+        cam.clip_end = 1000.0
+        ob = link(bpy.data.objects.new('gm-camera', cam))
+        ob.rotation_mode = 'XYZ'
+        ob.rotation_euler = (math.radians(90), 0, 0)
+        ob.location = (0.0, -200.0, (frame['bottom'] + frame['top']) / 2)
+        self.scene.camera = ob
+        self.scene.render.resolution_x = frame['w']
+        self.scene.render.resolution_y = frame['h']
+
+
+def write_result(out, result):
+    with open(os.path.join(out, 'result.json'), 'w') as f:
+        json.dump(result, f)
+
+
+def main():
+    job_path, out = sys.argv[sys.argv.index('--') + 1:][:2]
+    with open(job_path) as f:
+        job = json.load(f)
+    started = time.time()
+    result = Builder(job, out).run()
+    result['ms'] = int((time.time() - started) * 1000)
+    write_result(out, result)
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except Exception as error:
+        # The run says what stopped it, in words, then fails.
+        write_result(sys.argv[sys.argv.index('--') + 1:][1], {'ok': False, 'reason': '%s: %s' % (type(error).__name__, error)})
+        raise