@deepblend/dsh-blender-provider-local 0.2.20 → 0.3.0

package/python/deepblend_mesh_checks.py

@@ -0,0 +1,145 @@
+"""Double-precision arithmetic over the actual float32 Blender mesh positions.
+
+All shared-vertex neighbors enter the narrow phase. Tolerances are explicit;
+this remains a finite mesh test rather than exact algebraic certification.
+"""
+import math
+from collections import defaultdict
+
+def sub(a,b): return tuple(x-y for x,y in zip(a,b))
+def dot(a,b): return sum(x*y for x,y in zip(a,b))
+def cross(a,b): return (a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0])
+def length(a): return math.sqrt(dot(a,a))
+def normal(a,b,c):
+    n=cross(sub(b,a),sub(c,a));size=length(n)
+    return tuple(x/size for x in n) if size>0 else None
+
+def segment_triangle(p,q,a,b,c):
+    direction=sub(q,p);ab=sub(b,a);ac=sub(c,a)
+    v=cross(direction,ac);det=dot(ab,v)
+    scale=length(direction)*length(ab)*length(ac)
+    if scale==0 or abs(det)<=scale*1e-14:return None
+    origin=sub(p,a);u=dot(origin,v)/det
+    v=cross(origin,ab);w=dot(direction,v)/det;t=dot(ac,v)/det
+    eps=1e-12
+    if u < -eps or w < -eps or u+w > 1+eps or t < -eps or t > 1+eps:return None
+    return tuple(p[i]+t*direction[i] for i in range(3))
+
+def clip_area(a,b):
+    def side(p,x,y):return (y[0]-x[0])*(p[1]-x[1])-(y[1]-x[1])*(p[0]-x[0])
+    sign=1 if side(b[2],b[0],b[1])>0 else -1
+    poly=list(a)
+    for q,w in zip(b,b[1:]+b[:1]):
+        out=[]
+        for s,e in zip(poly,poly[1:]+poly[:1]):
+            ds,de=sign*side(s,q,w),sign*side(e,q,w)
+            if (ds>=0)!=(de>=0):
+                f=ds/(ds-de);out.append((s[0]+f*(e[0]-s[0]),s[1]+f*(e[1]-s[1])))
+            if de>=0:out.append(e)
+        poly=out
+        if not poly:return 0
+    return abs(sum(a[0]*b[1]-a[1]*b[0] for a,b in zip(poly,poly[1:]+poly[:1])))*.5
+
+def intersection_facts(mesh, max_candidates=2_000_000):
+    mesh.calc_loop_triangles();triangles=[tuple(t.vertices) for t in mesh.loop_triangles]
+    verts=[tuple(float(x) for x in v.co) for v in mesh.vertices]
+    extent=max(max(v[i] for v in verts)-min(v[i] for v in verts) for i in range(3))
+    cell=extent/24;bins=defaultdict(list);boxes=[]
+    for index,tri in enumerate(triangles):
+        lo=tuple(min(verts[j][i] for j in tri)-1e-10 for i in range(3))
+        hi=tuple(max(verts[j][i] for j in tri)+1e-10 for i in range(3));boxes.append((lo,hi))
+        for x in range(math.floor(lo[0]/cell),math.floor(hi[0]/cell)+1):
+            for y in range(math.floor(lo[1]/cell),math.floor(hi[1]/cell)+1):
+                for z in range(math.floor(lo[2]/cell),math.floor(hi[2]/cell)+1):bins[(x,y,z)].append(index)
+    pairs=set()
+    for values in bins.values():
+        for k,a in enumerate(values):
+            alo,ahi=boxes[a]
+            for b in values[k+1:]:
+                blo,bhi=boxes[b]
+                if all(alo[i]<=bhi[i] and blo[i]<=ahi[i] for i in range(3)):
+                    pairs.add((a,b))
+                    if len(pairs)>max_candidates:raise ValueError('mesh intersection validation exceeds its candidate-pair budget')
+    bad=[];coplanar=0;tested=0;normals=[]
+    for t in triangles:normals.append(normal(*(verts[i] for i in t)))
+    eps=1e-8
+    for ai,bi in pairs:
+        a,b=triangles[ai],triangles[bi];shared=set(a)&set(b);av=[verts[i] for i in a];bv=[verts[i] for i in b]
+        na,nb=normals[ai],normals[bi]
+        if na is None or nb is None:continue
+        is_coplanar=length(cross(na,nb))<1e-5 and max(abs(dot(na,sub(p,av[0]))) for p in bv)<1e-9
+        hit=False
+        if is_coplanar:
+            coplanar+=1;drop=max(range(3),key=lambda i:abs(na[i]));axes=[i for i in range(3) if i!=drop]
+            hit=clip_area([tuple(p[i] for i in axes) for p in av],[tuple(p[i] for i in axes) for p in bv])>1e-14
+        elif len(shared)<2:
+            tested+=1
+            for points,target in ((av,bv),(bv,av)):
+                for p,q in zip(points,points[1:]+points[:1]):
+                    where=segment_triangle(p,q,*target)
+                    if where is not None and not any(length(sub(where,verts[i]))<eps for i in shared):hit=True
+        if hit:bad.append({'triangles':[ai,bi],'sharedVertices':len(shared),'coplanar':is_coplanar})
+    return {'aabbCandidatePairs':len(pairs),'coplanarPairsChecked':coplanar,'noncoplanarPairsChecked':tested,
+        'intersectionsBeyondSharedBoundary':len(bad),'examples':bad[:12],
+        'method':'Explicit AABB bins include shared vertices; float64 segment/triangle and coplanar polygon clipping over actual mesh coordinates; only noncoplanar shared-edge adjacency exempt',
+        'toleranceM':eps,'coplanarAreaToleranceM2':1e-14,'planeToleranceM':1e-9,'barycentricTolerance':1e-12}
+
+
+def validate_corner_normals(mesh):
+    """Check actual stored normals, including their orientation on each triangle."""
+    normals = [tuple(float(c) for c in item.vector) for item in mesh.corner_normals]
+    if len(normals) != len(mesh.loops):
+        raise ValueError('missing corner normals')
+    if any(not all(math.isfinite(c) for c in n) or abs(length(n)-1)>1e-5 for n in normals):
+        raise ValueError('non-finite or non-unit corner normals')
+    mesh.calc_loop_triangles()
+    for triangle in mesh.loop_triangles:
+        points = [tuple(float(c) for c in mesh.vertices[i].co) for i in triangle.vertices]
+        face_normal = normal(*points)
+        if face_normal is None or any(dot(normals[i], face_normal)<=0 for i in triangle.loops):
+            raise ValueError('corner normal opposes its geometry triangle')
+
+
+def validate_handled_cup_mesh(mesh, parameters):
+    """Refuse invalid discrete output; do not publish a folded or open cup."""
+    import bmesh
+    from deepblend_util import ActionError
+    def invalid(message):
+        raise ActionError('SCENE_SPEC_INVALID', 'handled_cup output: '+message)
+    if not mesh.polygons or len(mesh.polygons)>100_000:
+        invalid('empty mesh or polygon budget exceeded')
+    if any(not math.isfinite(c) for vertex in mesh.vertices for c in vertex.co):
+        invalid('non-finite coordinates')
+    bm=bmesh.new()
+    try:
+        bm.from_mesh(mesh)
+        if any(not edge.is_manifold for edge in bm.edges):invalid('open or non-manifold boundary')
+        if any(face.calc_area()<=0 for face in bm.faces):invalid('zero-area face')
+        if len(bm.verts)-len(bm.edges)+len(bm.faces)!=0:invalid('unexpected cup/handle topology')
+        unseen=set(bm.verts);stack=[unseen.pop()]
+        while stack:
+            for edge in stack.pop().link_edges:
+                for vertex in edge.verts:
+                    if vertex in unseen:unseen.remove(vertex);stack.append(vertex)
+        if unseen:invalid('disconnected geometry')
+        if bm.calc_volume(signed=True)<=0:invalid('nonpositive signed volume')
+    finally:
+        bm.free()
+    uv=mesh.uv_layers.active
+    if uv is None or any(not math.isfinite(c) for item in uv.data for c in item.uv):invalid('missing or invalid UVs')
+    mesh.calc_loop_triangles()
+    for tri in mesh.loop_triangles:
+        points = [tuple(float(x) for x in mesh.vertices[i].co) for i in tri.vertices]
+        if length(cross(sub(points[1], points[0]), sub(points[2], points[0]))) <= 0:
+            invalid('zero-area geometry triangle')
+        a,b,c=(uv.data[i].uv for i in tri.loops)
+        if abs((b-a).cross(c-a))<1e-12:invalid('zero-area UV triangle')
+    if not mesh.has_custom_normals:invalid('missing analytic corner normals')
+    try:
+        validate_corner_normals(mesh)
+        intersections=intersection_facts(mesh)
+    except ValueError as error:
+        invalid(str(error))
+    if intersections['intersectionsBeyondSharedBoundary']:
+        invalid('triangles intersect beyond their shared boundary')
+    return intersections

package/python/deepblend_obj_images.py

@@ -0,0 +1,54 @@
+"""Inspect native-selected OBJ material textures before scene reset or decode."""
+import os
+import posixpath
+
+from deepblend_asset_bundle import inside, obj_reference, MAX_FILES
+from deepblend_obj_resources import obj_declarations, mtl_image_records
+from deepblend_imported_image_headers import check_imported_image_header
+from deepblend_image_headers import MAX_IMAGE_DECODE_BYTES
+from deepblend_util import ActionError
+
+# Native aliases share one map slot; later definitions replace that slot.
+ALIASES = {'map_refl': 'refl', 'map_Bump': 'bump', 'map_bump': 'bump'}
+
+
+def inspect_obj_images(project_root, asset):
+    entrypoint = asset['path']
+    libraries, names, used = [], set(), set()
+    for kind, name in obj_declarations(inside(project_root, entrypoint)):
+        if kind == 'usemtl':
+            used.add(name)
+        else:
+            # Native library de-duplication compares the declared spelling, before
+            # resolving paths. Distinct spellings may reapply the same MTL later.
+            if name not in names:
+                names.add(name)
+                libraries.append(obj_reference(entrypoint, name))
+    fallback = posixpath.splitext(entrypoint)[0] + '.mtl'
+    if os.path.exists(inside(project_root, fallback)) and posixpath.basename(fallback) not in names:
+        libraries.append(fallback)
+    if len(libraries) > MAX_FILES:
+        raise ActionError('ASSET_TOO_LARGE', 'OBJ material libraries exceed their resource limit')
+    selected = {}
+    for library in libraries:
+        for material, kind, name in mtl_image_records(inside(project_root, library)):
+            if material in used:
+                selected.setdefault(material, {})[ALIASES.get(kind, kind)] = obj_reference(library, name)
+    roles = {}
+    for maps in selected.values():
+        for kind, path in maps.items():
+            role = 'color' if kind in ('map_Kd', 'map_Ke') else 'alpha' if kind == 'map_d' else 'data'
+            roles.setdefault(path, set()).add(role)
+    paths = sorted(roles)
+    if len(paths) > MAX_FILES:
+        raise ActionError('ASSET_TOO_LARGE', 'OBJ textures exceed their resource limit')
+    facts, total, allocations = [], 0, 0
+    for path in paths:
+        header = check_imported_image_header(inside(project_root, path))
+        count = max(1, len(roles[path] - {'alpha'}))
+        facts.append({'path': path, 'roles': sorted(roles[path]), 'allocations': count, **header})
+        allocations += count
+        total += count * header['decodedBytes']
+        if total > MAX_IMAGE_DECODE_BYTES:
+            raise ActionError('ASSET_CONTENT_MISMATCH', 'imported OBJ images exceed the 1 GiB decoded pixel budget')
+    return {'images': len(facts), 'allocations': allocations, 'decodedBytes': total, 'facts': facts}

package/python/deepblend_obj_import.py

@@ -0,0 +1,58 @@
+"""Use linear OBJ numeric/normal maps while retaining native color images."""
+import bpy
+from deepblend_image_roles import SOURCE_SPACE
+
+# A later import can reuse an image first encountered as data. Remember its
+# native color interpretation before changing it, including float-file spaces.
+def image_role(node):
+    roles = set()
+    for link in node.outputs['Color'].links:
+        numeric = (link.to_node.type == 'BSDF_PRINCIPLED' and link.to_socket.type == 'VALUE')
+        normal = (link.to_node.type == 'NORMAL_MAP' and link.to_socket.name == 'Color')
+        roles.add('data' if numeric or normal else 'color')
+    if len(roles) > 1:
+        raise ValueError('native OBJ image node has conflicting RGB uses')
+    return next(iter(roles)) if roles else 'neutral'
+
+
+def assign_image_roles(objects, protected_images):
+    materials = {slot.material for obj in objects for slot in getattr(obj, 'material_slots', [])
+                 if slot.material and slot.material.use_nodes}
+    uses = {}
+    for material in materials:
+        for node in material.node_tree.nodes:
+            if node.type == 'TEX_IMAGE' and node.image:
+                uses.setdefault(node.image, []).append((node, image_role(node)))
+    for original, nodes in uses.items():
+        roles = {role for _, role in nodes if role != 'neutral'}
+        if not roles:
+            continue
+        native_space = original.get(SOURCE_SPACE, original.colorspace_settings.name)
+        spaces = {'color': native_space, 'data': 'Non-Color'}
+        images = {}
+        for role in sorted(roles):
+            space = spaces[role]
+            if original.colorspace_settings.name == space:
+                image = original
+            elif (len(roles) == 1 and original not in protected_images
+                  and original.users == len(nodes)):
+                # All users are this import. Alpha and disconnected nodes can
+                # share its RGB interpretation without another allocation.
+                image = original
+                image[SOURCE_SPACE] = native_space
+                image.colorspace_settings.name = space
+            else:
+                image = original.copy()
+                image[SOURCE_SPACE] = native_space
+                image.colorspace_settings.name = space
+            images[role] = image
+        neutral_role = 'color' if 'color' in images else 'data'
+        for node, role in nodes:
+            node.image = images[neutral_role if role == 'neutral' else role]
+
+
+def import_obj(path):
+    before_objects, before_images = set(bpy.data.objects), set(bpy.data.images)
+    result = bpy.ops.wm.obj_import(filepath=path)
+    assign_image_roles([obj for obj in bpy.data.objects if obj not in before_objects], before_images)
+    return result

package/python/deepblend_obj_resources.py

@@ -0,0 +1,79 @@
+"""Bounded OBJ/MTL reference inspection; independent of Node and bpy."""
+import os,re
+from deepblend_util import ActionError
+MAX_OBJ=1024*1024*1024
+MAX_MTL=16*1024*1024
+MAX_LINE=1024*1024
+MAP_KEYS={'map_Kd','map_Ks','map_Ns','map_d','refl','map_refl','map_Ke','bump','map_Bump','map_bump','map_Pr','map_Pm','map_Ps'}
+COUNTS={'-bm':1,'-type':1,'-blendu':1,'-blendv':1,'-boost':1,'-cc':1,'-clamp':1,'-imfchan':1,'-mm':2,'-t':3,'-texres':1}
+
+def fail(message,code='ASSET_REQUEST_INVALID'):raise ActionError(code,message)
+def numeric(value):
+    if not re.fullmatch(r'[+-]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:e[+-]?[0-9]+)?',value,re.I):return False
+    import math
+    return math.isfinite(float(value))
+
+def lines(path,limit,continuation=False):
+    try:
+        if os.path.getsize(path)>limit:fail('OBJ/MTL text exceeds its byte limit.','ASSET_TOO_LARGE')
+        total=0;logical='';first=True
+        with open(path,'rb') as source:
+            while True:
+                raw=source.readline(MAX_LINE+2)
+                if not raw:
+                    if logical:yield logical
+                    break
+                total+=len(raw)
+                if total>limit:fail('OBJ/MTL text exceeds its byte limit.','ASSET_TOO_LARGE')
+                physical=raw.rstrip(b'\n')
+                if len(physical)>MAX_LINE:fail('OBJ/MTL lines exceed 1 MiB.','ASSET_TOO_LARGE')
+                line=physical.decode('utf-8-sig' if first else 'utf-8');first=False
+                continued=continuation and re.search(r'\\[\t\r ]*$',line)
+                logical+=re.sub(r'\\[\t\r ]*$',' ',line) if continued else line
+                if len(logical.encode('utf-8'))>MAX_LINE:fail('OBJ/MTL logical lines exceed 1 MiB.','ASSET_TOO_LARGE')
+                if not continued:yield logical;logical=''
+    except UnicodeError:fail('OBJ/MTL text must be valid UTF-8.','ASSET_CONTENT_MISMATCH')
+    except OSError:fail('An OBJ/MTL file is missing.','ASSET_MISSING')
+
+def obj_declarations(path):
+    for line in lines(path,MAX_OBJ,True):
+        field=line.split(None,1)
+        if not field or field[0] not in ('mtllib','usemtl'):continue
+        name=field[1].strip() if len(field)>1 else ''
+        if field[0]=='mtllib':
+            if len(name)>2 and name.startswith('"') and name.endswith('"'):name=name[1:-1]
+            if not name:fail('An OBJ material library reference is empty.')
+        yield field[0],name
+
+def obj_libraries(path):
+    return {name for kind,name in obj_declarations(path) if kind=='mtllib'}
+
+def mtl_image_records(path):
+    material=None
+    for line in lines(path,MAX_MTL):
+        field=line.split(None,1)
+        if not field:continue
+        if field[0]=='newmtl':material=field[1].strip() if len(field)>1 else '';continue
+        if material is None or field[0] not in MAP_KEYS:continue
+        rest=field[1].strip() if len(field)>1 else ''
+        while rest:
+            token=rest.split(None,1)[0]
+            if token in ('-o','-s'):
+                rest=rest[len(token):].lstrip()
+                for i in range(3):
+                    value=rest.split(None,1)[0] if rest else ''
+                    if not numeric(value):break
+                    rest=rest[len(value):].lstrip()
+            elif token in COUNTS:
+                rest=rest[len(token):].lstrip()
+                for i in range(COUNTS[token]):
+                    value=rest.split(None,1)[0] if rest else ''
+                    if not value or (token=='-bm' and not numeric(value)):fail('An MTL texture option is incomplete or invalid.')
+                    rest=rest[len(value):].lstrip()
+            else:break
+        name=rest.strip().replace('"','')
+        if not name:fail('An MTL texture reference is empty.')
+        yield material,field[0],name
+
+def mtl_images(path):
+    return {name for material,kind,name in mtl_image_records(path)}

package/python/deepblend_parts.py

@@ -0,0 +1,106 @@
+"""Stable imported-part selectors and object-local material slot overrides."""
+from contextlib import contextmanager
+import uuid
+import json
+import bpy
+from deepblend_util import ActionError
+
+
+@contextmanager
+def isolated_import_names(instance_name):
+    # Importers may name unnamed nodes after meshes, cameras, or other data.
+    # Reserve all existing names so prior instances cannot change source paths.
+    names = ('objects', 'meshes', 'curves', 'armatures', 'cameras', 'lights',
+             'metaballs', 'lattices', 'collections')
+    snapshots = [(getattr(bpy.data, name), [(item, item.name) for item in getattr(bpy.data, name)])
+                 for name in names]
+    nonce = uuid.uuid4().hex[:16]
+    try:
+        for collection_index, (_, entries) in enumerate(snapshots):
+            for index, (item, _) in enumerate(entries):
+                item.name = '_db_%s_%d_%d' % (nonce, collection_index, index)
+        yield
+    finally:
+        for collection_index, (collection, entries) in enumerate(snapshots):
+            old_items = {item for item, _ in entries}
+            old_names = {name for _, name in entries}
+            displaced = []
+            for index, item in enumerate(list(collection)):
+                if item not in old_items and item.name in old_names:
+                    desired = '%s_%s' % (instance_name, item.name)
+                    item.name = '_db_%s_new_%d_%d' % (nonce, collection_index, index)
+                    displaced.append((item, desired))
+            for item, original in entries:
+                item.name = original
+            for item, desired in displaced:
+                item.name = desired
+
+
+
+def stamp_imported_parts(objects):
+    imported = set(objects)
+    paths = {}
+    def path(obj):
+        if obj not in paths:
+            segment = obj.name.replace('~', '~0').replace('/', '~1')
+            paths[obj] = (path(obj.parent) if obj.parent in imported else '') + '/' + segment
+        return paths[obj]
+    for obj in objects:
+        obj['deepblend_part_id'] = path(obj)
+        obj['deepblend_parent_part_id'] = path(obj.parent) if obj.parent in imported else ''
+        if obj.type == 'MESH':
+            obj['deepblend_source_material_slots'] = json.dumps([
+                {'index': index, 'materialName': slot.material.name if slot.material else None}
+                for index, slot in enumerate(obj.material_slots)])
+
+
+def apply_material_bindings(entity, objects, materials):
+    bindings = entity.get('materialBindings') or []
+    meshes = [obj for obj in objects if obj.type == 'MESH']
+    inventory = [{'partId': obj.get('deepblend_part_id'), 'slotCount': len(obj.material_slots)} for obj in meshes]
+    def fail(message):
+        raise ActionError('SCENE_VALIDATION_FAILED', 'entity "%s": %s' % (entity['id'], message),
+                          {'entityId': entity['id'], 'availableParts': inventory})
+    selected = []
+    seen = set()
+    for binding in bindings:
+        key = (binding['partId'], binding.get('slotIndex'))
+        if key in seen:
+            fail('duplicate material binding for %s' % (key,))
+        seen.add(key)
+        matches = [obj for obj in meshes if obj.get('deepblend_part_id') == binding['partId']]
+        if len(matches) != 1:
+            fail('material partId "%s" must select exactly one mesh' % binding['partId'])
+        obj = matches[0]
+        slot_index = binding.get('slotIndex')
+        if slot_index is not None and (slot_index < 0 or slot_index >= len(obj.material_slots)):
+            fail('slotIndex %s is outside the original slots of "%s"' % (slot_index, binding['partId']))
+        material = materials.get(binding['materialId'])
+        if material is None:
+            fail('material "%s" was not built' % binding['materialId'])
+        selected.append((obj, slot_index, material))
+
+    def assign(obj, material, slot_index=None):
+        if not obj.material_slots:
+            # A new slot changes shared mesh data; isolate only this zero-slot case.
+            if obj.data.users > 1:
+                obj.data = obj.data.copy()
+            obj.data.materials.append(material)
+        indices = range(len(obj.material_slots)) if slot_index is None else [slot_index]
+        for index in indices:
+            slot = obj.material_slots[index]
+            slot.link = 'OBJECT'
+            slot.material = material
+
+    if entity.get('materialId') is not None:
+        material = materials.get(entity['materialId'])
+        if material is None:
+            fail('material "%s" was not built' % entity['materialId'])
+        for obj in objects:
+            if hasattr(obj.data, "materials"):
+                assign(obj, material)
+    # A slot-specific override always wins, independently of declaration order.
+    for specific in (False, True):
+        for obj, slot_index, material in selected:
+            if (slot_index is not None) == specific:
+                assign(obj, material, slot_index)

package/python/deepblend_render.py

@@ -25,9 +25,58 @@ import os
 import bpy
 
 from deepblend_scene import describe_objects, resolve_engine
+from deepblend_anisotropy import validate_anisotropy_render_engine
 from deepblend_util import ActionError, error_text, report_progress
 
 
+def _camera_facts(scene, camera):
+    """Evaluated camera optics and pose for one rendered frame.
+
+    Matrix rows are copied to plain numbers so later frames cannot mutate the
+    record. A focus object is evaluated too: its animation changes depth of field
+    even when the camera's stored focus_distance is unchanged.
+    Lens and sensor dimensions are millimetres; transforms use scene units.
+    """
+    if camera is None:
+        raise ActionError("SCENE_CAMERA_MISSING", "the rendered scene has no active camera")
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+    evaluated = camera.evaluated_get(depsgraph)
+    data = evaluated.data
+    dof = data.dof
+    focus = dof.focus_object
+    focus_facts = None
+    if focus is not None:
+        focus_facts = {
+            "name": focus.name,
+            "entityId": focus.get("deepblend_id"),
+            "matrixWorld": [[float(value) for value in row]
+                            for row in focus.evaluated_get(depsgraph).matrix_world],
+        }
+    return {
+        "frame": int(scene.frame_current),
+        "matrixWorld": [[float(value) for value in row] for row in evaluated.matrix_world],
+        "type": data.type,
+        "lens": float(data.lens),
+        "orthoScale": float(data.ortho_scale),
+        "sensorWidth": float(data.sensor_width),
+        "sensorHeight": float(data.sensor_height),
+        "sensorFit": data.sensor_fit,
+        "shift": [float(data.shift_x), float(data.shift_y)],
+        "clip": [float(data.clip_start), float(data.clip_end)],
+        "dof": {
+            "enabled": bool(dof.use_dof),
+            "focusDistance": float(dof.focus_distance),
+            "focusObject": focus_facts,
+            "focusSubtarget": getattr(dof, "focus_subtarget", "") or None,
+            "apertureFstop": float(dof.aperture_fstop),
+            "apertureBlades": int(dof.aperture_blades),
+            "apertureRotation": float(dof.aperture_rotation),
+            "apertureRatio": float(dof.aperture_ratio),
+        },
+    }
+
+
+
 def open_checkpoint(path):
     """Open a ``.blend`` checkpoint and return its scene.
 
@@ -107,6 +156,7 @@ def apply_render_overrides(scene, options, guard):
         engine, downgrade = resolve_engine(engine_key, guard)
         if downgrade is not None:
             guard.warnings.append(downgrade)
+        validate_anisotropy_render_engine(scene, engine)
         if scene.render.engine != engine:
             scene.render.engine = engine
             applied["engine"] = engine
@@ -116,6 +166,8 @@ def apply_render_overrides(scene, options, guard):
                 % (engine, checkpoint_profile(scene).get("engine", "<unknown>")),
                 {"engine": engine},
             )
+    else:
+        validate_anisotropy_render_engine(scene, scene.render.engine)
 
     width = options.get("width")
     height = options.get("height")
@@ -241,6 +293,7 @@ def render_preview(options=None, guard=None, checkpoint=None, output=None, camer
         "cameraId": camera.get("deepblend_id") or camera.name,
         "cameraName": camera.name,
         "lens": round(float(camera.data.lens), 6),
+        "cameraFacts": _camera_facts(scene, camera),
         "overrides": overrides,
         "renderConfig": _render_config(scene),
         "objects": describe_objects(),