Skip to content

3D engine that AI agents drive

16.2 KB
Raw Blame
"""Dumps what Blender's own build offers, as JSON, for the parity comparison.

Run headless with factory settings (no add-ons beyond the defaults):
  blender -b --factory-startup --python scripts/blender-inventory.py -- bench/parity/blender-inventory.json
The output path is the first argument after "--". Compare with: node scripts/blender-inventory-compare.mjs
"""
import ast
import json
import os
import re
import sys

import bpy


def output_path():
    arguments = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
    return arguments[0] if arguments else "bench/parity/blender-inventory.json"


def enum_items(owner_type, property_name):
    """Enum items of a property on an RNA type, as identifier, name and description."""
    property_definition = owner_type.bl_rna.properties[property_name]
    return [
        {"identifier": item.identifier, "name": item.name, "description": item.description}
        for item in property_definition.enum_items
    ]


def property_summary(owner_type):
    """Every property of an RNA type with its kind, so settings groups can be listed."""
    summary = []
    for property_definition in owner_type.bl_rna.properties:
        if property_definition.identifier == "rna_type":
            continue
        entry = {
            "identifier": property_definition.identifier,
            "name": property_definition.name,
            "type": property_definition.type,
        }
        if property_definition.type == "ENUM":
            entry["enum_items"] = [item.identifier for item in property_definition.enum_items]
        summary.append(entry)
    return summary


def safe(function, fallback):
    """Runs one inventory step; a failing step is recorded instead of losing the whole dump."""
    try:
        return function()
    except Exception as error:
        return {"error": f"{type(error).__name__}: {error}", "fallback": fallback}


def operator_enum_items(operator_function, property_name):
    rna = operator_function.get_rna_type()
    return [
        {"identifier": item.identifier, "name": item.name}
        for item in rna.properties[property_name].enum_items
    ]


def all_subclasses(base_type):
    """Every registered subclass of a Blender UI or node type, at any depth."""
    found = []
    pending = list(base_type.__subclasses__())
    while pending:
        subclass = pending.pop()
        if subclass not in found:
            found.append(subclass)
            pending.extend(subclass.__subclasses__())
    return found


def panel_layout():
    panels = []
    for panel_class in all_subclasses(bpy.types.Panel):
        panels.append({
            "idname": getattr(panel_class, "bl_idname", None) or panel_class.bl_rna.identifier,
            "label": getattr(panel_class, "bl_label", None) or panel_class.bl_rna.name,
            "space_type": getattr(panel_class, "bl_space_type", None),
            "region_type": getattr(panel_class, "bl_region_type", None),
            "context": getattr(panel_class, "bl_context", None) or None,
            "category": getattr(panel_class, "bl_category", None) or None,
            "parent_id": getattr(panel_class, "bl_parent_id", None) or None,
        })
    panels.sort(key=lambda entry: (entry["space_type"] or "", entry["region_type"] or "", entry["context"] or "", entry["idname"]))
    return panels


def menu_list():
    menus = [
        {
            "idname": getattr(menu_class, "bl_idname", None) or menu_class.bl_rna.identifier,
            "label": getattr(menu_class, "bl_label", None) or menu_class.bl_rna.name,
        }
        for menu_class in all_subclasses(bpy.types.Menu)
    ]
    menus.sort(key=lambda entry: entry["idname"])
    return menus


def operator_inventory():
    categories = {}
    for category_name in sorted(dir(bpy.ops)):
        if category_name.startswith("_"):
            continue
        category = getattr(bpy.ops, category_name)
        operators = []
        for operator_name in sorted(dir(category)):
            if operator_name.startswith("_"):
                continue
            try:
                rna = getattr(category, operator_name).get_rna_type()
                operators.append({"name": operator_name, "label": rna.name, "description": rna.description})
            except Exception:
                operators.append({"name": operator_name, "label": "", "description": ""})
        categories[category_name] = {"count": len(operators), "operators": operators}
    return categories


def node_classes(base_type):
    entries = {}
    # Built-in nodes are C types that do not appear in __subclasses__, so scan bpy.types by name.
    prefixes = ("GeometryNode", "FunctionNode") if base_type is bpy.types.GeometryNode else (base_type.__name__,)
    for type_name in dir(bpy.types):
        node_class = getattr(bpy.types, type_name)
        is_node = isinstance(node_class, type) and issubclass(node_class, bpy.types.Node)
        if is_node and type_name.startswith(prefixes) and type_name not in ("GeometryNode", "FunctionNode") and type_name != base_type.__name__:
            entries[type_name] = node_class.bl_rna.name
    return entries


def menu_path(class_name, label):
    """Top menu and submenu, such as "Mesh > Operations", from a class like NODE_MT_gn_mesh_operations_base."""
    tokens = [token for token in class_name.replace("NODE_MT_", "").replace("_base", "").split("_")
              if token not in ("gn", "category", "compositor", "shader", "node", "cmp")]
    if not tokens:
        return label
    top_length = 2 if tokens[:2] == ["grease", "pencil"] else 1
    top = " ".join(tokens[:top_length]).title()
    return label if len(tokens) == top_length else f"{top} > {label}"


def add_menu_categories(file_name, node_names):
    """Groups node types by the Add menu class that lists them, read from Blender's own menu source."""
    source_path = os.path.join(bpy.utils.system_resource("SCRIPTS"), "startup", "bl_ui", file_name)
    with open(source_path, encoding="utf-8") as source_file:
        source = source_file.read()
    class_pattern = re.compile(r"^class (\w+)\(.*?\):\n(.*?)(?=^class |\Z)", re.S | re.M)
    categories = {}
    listed = set()
    for match in class_pattern.finditer(source):
        class_name, body = match.group(1), match.group(2)
        if not class_name.startswith("NODE_MT_"):
            continue
        label_match = re.search(r'bl_label = "([^"]+)"', body)
        label = menu_path(class_name, label_match.group(1) if label_match else class_name)
        members = re.findall(r'"((?:Geometry|Shader|Compositor|Function)Node\w+)"', body)
        members = [name for name in dict.fromkeys(members) if name in node_names]
        for name in members:
            categories.setdefault(label, [])
            if name not in categories[label]:
                categories[label].append(name)
            listed.add(name)
    unlisted = sorted(set(node_names) - listed)
    return categories, unlisted


def node_inventory(base_type, menu_file):
    names = node_classes(base_type)
    categories, unlisted = add_menu_categories(menu_file, names)
    return {
        "count": len(names),
        "add_menu_categories": {
            label: [{"idname": name, "label": names[name]} for name in members]
            for label, members in sorted(categories.items())
        },
        "not_in_add_menu": [{"idname": name, "label": names[name]} for name in unlisted],
    }


def physics_inventory():
    scene = bpy.context.scene
    return {
        "force_field_types": enum_items(bpy.types.FieldSettings, "type"),
        "particle_system_types": enum_items(bpy.types.ParticleSettings, "type"),
        "rigid_body_types": enum_items(bpy.types.RigidBodyObject, "type"),
        "rigid_body_collision_shapes": enum_items(bpy.types.RigidBodyObject, "collision_shape"),
        "rigid_body_constraint_types": enum_items(bpy.types.RigidBodyConstraint, "type"),
        "fluid_types": enum_items(bpy.types.FluidModifier, "fluid_type"),
        "dynamic_paint_types": enum_items(bpy.types.DynamicPaintModifier, "ui_type"),
        "settings": {
            "cloth": property_summary(bpy.types.ClothSettings),
            "cloth_collision": property_summary(bpy.types.ClothCollisionSettings),
            "soft_body": property_summary(bpy.types.SoftBodySettings),
            "fluid_domain": property_summary(bpy.types.FluidDomainSettings),
            "fluid_flow": property_summary(bpy.types.FluidFlowSettings),
            "dynamic_paint_surface": property_summary(bpy.types.DynamicPaintSurface),
            "particle_settings": property_summary(bpy.types.ParticleSettings),
            "force_field": property_summary(bpy.types.FieldSettings),
            "rigid_body_world": property_summary(bpy.types.RigidBodyWorld),
            "rigid_body_object": property_summary(bpy.types.RigidBodyObject),
        },
        "scene_has_rigid_body_world": scene.rigidbody_world is not None,
    }


def render_inventory():
    scene = bpy.context.scene
    engines = [
        {"identifier": engine_class.bl_idname, "name": engine_class.bl_label}
        for engine_class in all_subclasses(bpy.types.RenderEngine)
        if getattr(engine_class, "bl_idname", "")
    ]
    known_names = {engine["identifier"] for engine in engines}
    for candidate in ("BLENDER_EEVEE", "BLENDER_WORKBENCH", "CYCLES"):
        # EEVEE and Workbench are built in and not Python classes; the scene accepts a valid engine name only.
        try:
            scene.render.engine = candidate
        except TypeError:
            continue
        if candidate not in known_names:
            engines.append({"identifier": candidate, "name": candidate.replace("BLENDER_", "").title()})
            known_names.add(candidate)
    # Every engine's settings live on the scene (eevee, cycles) or the display (workbench); read what is registered.
    settings = {}
    if hasattr(scene, "eevee"):
        settings["scene.eevee"] = property_summary(type(scene.eevee))
    if hasattr(scene, "cycles"):
        settings["scene.cycles"] = property_summary(type(scene.cycles))
        settings["view_layer.cycles"] = property_summary(type(scene.view_layers[0].cycles))
    settings["scene.display.shading"] = property_summary(type(scene.display.shading))
    return {
        "engines": engines,
        "engine_settings": settings,
        "scene_render": property_summary(bpy.types.RenderSettings),
        "image_format": property_summary(bpy.types.ImageFormatSettings),
        "ffmpeg": property_summary(bpy.types.FFmpegSettings),
        "view_layer": property_summary(bpy.types.ViewLayer),
        "image_file_formats": enum_items(bpy.types.ImageFormatSettings, "file_format"),
        "video_containers": enum_items(bpy.types.FFmpegSettings, "format"),
        "video_codecs": enum_items(bpy.types.FFmpegSettings, "codec"),
    }


def live_enum_identifiers(owner, property_name):
    """OpenColorIO enums are not in the RNA items; Blender lists them in the error for a bad value."""
    try:
        setattr(owner, property_name, "__not_a_value__")
    except TypeError as error:
        listed = re.search(r"in (\(.*\))\s*$", str(error))
        if listed:
            return list(ast.literal_eval(listed.group(1)))
    return []


def color_management_inventory():
    view_settings = bpy.context.scene.view_settings
    display_settings = bpy.context.scene.display_settings
    view_transforms = live_enum_identifiers(view_settings, "view_transform")
    looks_by_view_transform = {}
    for view_transform in view_transforms:
        view_settings.view_transform = view_transform
        looks_by_view_transform[view_transform] = live_enum_identifiers(view_settings, "look")
    return {
        "view_transforms": view_transforms,
        "looks_by_view_transform": looks_by_view_transform,
        "display_devices": live_enum_identifiers(display_settings, "display_device"),
        "view_settings": property_summary(bpy.types.ColorManagedViewSettings),
    }


def light_camera_world_inventory():
    return {
        "light_types": enum_items(bpy.types.Light, "type"),
        "light_settings": {
            "Light": property_summary(bpy.types.Light),
            "PointLight": property_summary(bpy.types.PointLight),
            "SunLight": property_summary(bpy.types.SunLight),
            "SpotLight": property_summary(bpy.types.SpotLight),
            "AreaLight": property_summary(bpy.types.AreaLight),
        },
        "light_probe_types": enum_items(bpy.types.LightProbe, "type"),
        "camera_types": enum_items(bpy.types.Camera, "type"),
        "camera_settings": property_summary(bpy.types.Camera),
        "camera_dof": property_summary(bpy.types.CameraDOFSettings),
        "world_settings": property_summary(bpy.types.World),
        "world_mist": property_summary(bpy.types.WorldMistSettings),
        "object_types": enum_items(bpy.types.Object, "type"),
        "mesh_primitive_operators": sorted(name for name in dir(bpy.ops.mesh) if name.startswith("primitive_")),
    }


def import_export_inventory():
    matches = []
    for category_name in sorted(dir(bpy.ops)):
        if category_name.startswith("_"):
            continue
        category = getattr(bpy.ops, category_name)
        for operator_name in sorted(dir(category)):
            lowered = operator_name.lower()
            if operator_name.startswith("_"):
                continue
            is_transfer = category_name.startswith(("import_", "export_")) or (
                lowered.endswith("_import") or lowered.endswith("_export")
                or lowered.startswith("import_") or lowered.startswith("export_")
            )
            if not is_transfer:
                continue
            try:
                rna = getattr(category, operator_name).get_rna_type()
                matches.append({"operator": f"{category_name}.{operator_name}", "label": rna.name, "description": rna.description})
            except Exception:
                matches.append({"operator": f"{category_name}.{operator_name}", "label": "", "description": ""})
    return matches


def modifier_constraint_inventory():
    return {
        "modifier_types": enum_items(bpy.types.Modifier, "type"),
        "constraint_types": enum_items(bpy.types.Constraint, "type"),
        "bone_constraint_types": operator_enum_items(bpy.ops.pose.constraint_add, "type"),
    }


def build_inventory():
    operators = operator_inventory()
    return {
        "blender_version": bpy.app.version_string,
        "blender_version_tuple": list(bpy.app.version),
        "factory_startup": True,
        "enabled_add_ons": sorted(bpy.context.preferences.addons.keys()),
        "ui": {"panels": safe(panel_layout, []), "menus": safe(menu_list, [])},
        "operators": operators,
        "operator_totals": {
            "categories": len(operators),
            "operators": sum(entry["count"] for entry in operators.values()),
        },
        "modifiers_and_constraints": safe(modifier_constraint_inventory, {}),
        "geometry_nodes": safe(lambda: node_inventory(bpy.types.GeometryNode, "node_add_menu_geometry.py"), {}),
        "shader_nodes": safe(lambda: node_inventory(bpy.types.ShaderNode, "node_add_menu_shader.py"), {}),
        "compositor_nodes": safe(lambda: node_inventory(bpy.types.CompositorNode, "node_add_menu_compositor.py"), {}),
        "physics": safe(physics_inventory, {}),
        "render": safe(render_inventory, {}),
        "color_management": safe(color_management_inventory, {}),
        "lights_cameras_world": safe(light_camera_world_inventory, {}),
        "import_export_operators": safe(import_export_inventory, []),
    }


def scrub(value):
    """Removes local paths and the user name from every string in the result."""
    home = os.path.expanduser("~")
    user = os.path.basename(home)
    if isinstance(value, str):
        text = value.replace(home, "~").replace(home.replace("\\", "/"), "~")
        return re.sub(re.escape(user), "user", text, flags=re.I) if user else text
    if isinstance(value, list):
        return [scrub(item) for item in value]
    if isinstance(value, dict):
        return {scrub(key): scrub(item) for key, item in value.items()}
    return value


def main():
    inventory = scrub(build_inventory())
    path = output_path()
    os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
    with open(path, "w", encoding="utf-8", newline="\n") as output_file:
        json.dump(inventory, output_file, indent=1, ensure_ascii=False)
        output_file.write("\n")
    print("inventory written", inventory["operator_totals"])


main()