Python scripting (bpy)

# macOS: the blender binary lives inside the app bundle
B=/Applications/Blender.app/Contents/MacOS/Blender
"$B" -b scene.blend --python export.py -- --out build
"$B" -b --python-expr \
  "import bpy; print(bpy.app.version_string)"
"$B" -b scene.blend --python-exit-code 1 --python check.py

import subprocess
import sys
 
import bpy
 
target = bpy.utils.user_resource(
    'SCRIPTS', path="modules", create=True)
subprocess.run([sys.executable, "-m", "ensurepip"],
               check=True)
subprocess.run([sys.executable, "-m", "pip", "install",
                "--target", target, "shapely"], check=True)

import bpy
 
verts = [(0, 0, 0), (2, 0, 0), (2, 1, 0), (0, 1, 0),
         (1, 0.5, 1)]
faces = [(3, 2, 1, 0), (0, 1, 4), (1, 2, 4),
         (2, 3, 4), (3, 0, 4)]   # counter-clockwise = out
 
me = bpy.data.meshes.new("Roof")
me.from_pydata(verts, [], faces)
me.validate()                  # fix bad indices, if any
ob = bpy.data.objects.new("Roof", me)
bpy.context.scene.collection.objects.link(ob)
ob.location = (0, 0, 3)

import bmesh
import bpy
from mathutils import Matrix
 
bm = bmesh.new()
bmesh.ops.create_cube(
    bm, size=1.0,
    matrix=Matrix.Translation((0, 0, 0.5)))  # sits on 0
top = [f for f in bm.faces if f.normal.z > 0.9]
bmesh.ops.inset_region(bm, faces=top, thickness=0.1)
me = bpy.data.meshes.new("Crate")
bm.to_mesh(me)
bm.free()                      # always free

bev = ob.modifiers.new(name="Bevel", type='BEVEL')
bev.width = 0.02               # meters
bev.segments = 3
bev.limit_method = 'ANGLE'
bev.harden_normals = True
wn = ob.modifiers.new("WeightedNormal", 'WEIGHTED_NORMAL')
wn.keep_sharp = True

def set_gn_input(mod, name, value):
    item = mod.node_group.interface.items_tree[name]
    getattr(mod.properties.inputs, item.identifier) \
        .value = value
 
gn = ob.modifiers.new("Facade", 'NODES')
gn.node_group = bpy.data.node_groups["Facade"]
set_gn_input(gn, "Floors", 6)

mat = bpy.data.materials.new("Brick")
bsdf = mat.node_tree.nodes["Principled BSDF"]
bsdf.inputs["Base Color"].default_value = (
    0.55, 0.18, 0.1, 1.0)      # linear RGBA
bsdf.inputs["Roughness"].default_value = 0.8
bsdf.inputs["Metallic"].default_value = 0.0
mat.diffuse_color = (0.55, 0.18, 0.1, 1.0)  # viewport
ob.data.materials.append(mat)  # adds a material slot

scene = bpy.context.scene
kit = bpy.data.collections.new("Kit")
scene.collection.children.link(kit)   # show it
 
def move_to(ob, col):
    for old in ob.users_collection:
        old.objects.unlink(ob)
    col.objects.link(ob)
 
move_to(ob, kit)

# every selected mesh: rename, then add a bevel
for ob in bpy.context.selected_objects:
    if ob.type != 'MESH':
        continue
    if not ob.name.startswith("SM_"):
        ob.name = f"SM_{ob.name}"
    if "Bevel" not in ob.modifiers:
        ob.modifiers.new("Bevel", 'BEVEL')

from bpy_extras import anim_utils
 
ob.location = (0, 0, 0)
ob.keyframe_insert("location", frame=1)
ob.location.z = 0.2
ob.keyframe_insert("location", frame=31)
ob.location.z = 0.0
ob.keyframe_insert("location", frame=61)
 
ad = ob.animation_data
ad.action.name = "Hover-loop"      # clip name on export
bag = anim_utils.action_get_channelbag_for_slot(
    ad.action, ad.action_slot)
for fc in bag.fcurves:             # one per axis
    for kp in fc.keyframe_points:
        kp.interpolation = 'SINE'
    fc.modifiers.new('CYCLES')     # loop in Blender

from math import radians
 
from mathutils import Euler, Matrix, Vector
 
ob.rotation_euler = Euler((0, 0, radians(90)), 'XYZ')
up = ob.matrix_world.to_3x3() @ Vector((0, 0, 1))
tip = ob.matrix_world @ Vector((0, 0, 2))  # local → world
ob.matrix_world = Matrix.Translation((4, 0, 0)) \
    @ ob.matrix_world               # move in world space

def apply_transform(ob):
    basis = ob.matrix_basis.copy()
    ob.data.transform(basis)      # affects every user
    for child in ob.children:
        child.matrix_parent_inverse = (
            basis @ child.matrix_parent_inverse)
    ob.matrix_basis.identity()

objs = [o for o in bpy.data.objects if o.type == 'MESH']
with bpy.context.temp_override(
        selected_editable_objects=objs,
        active_object=objs[0]):
    bpy.ops.object.transform_apply(
        location=False, rotation=True, scale=True)

import bpy
from pathlib import Path
 
def export_collections(out_dir: str) -> int:
    out = Path(bpy.path.abspath(out_dir))
    out.mkdir(parents=True, exist_ok=True)
    count = 0
    for col in bpy.data.collections:
        if not col.all_objects or col.name.startswith("_"):
            continue
        name = bpy.path.clean_name(col.name)
        bpy.ops.export_scene.gltf(
            filepath=str(out / f"{name}.glb"),
            export_format='GLB',
            collection=col.name,
            export_apply=True,
            export_draco_mesh_compression_enable=True,
        )
        count += 1
    return count
 
export_collections("//export")   # // = next to the .blend

B=/Applications/Blender.app/Contents/MacOS/Blender
"$B" -b shot.blend -E CYCLES -o //renders/f_#### -F PNG -f 1
"$B" -b shot.blend -a                   # whole frame range
"$B" -b shot.blend -o //r/f_#### -s 1 -e 48 -a

scene = bpy.context.scene
scene.render.engine = 'CYCLES'     # or 'BLENDER_EEVEE'
scene.render.resolution_x = 1920
scene.render.resolution_y = 1080
settings = scene.render.image_settings
settings.media_type = 'IMAGE'      # 5.0+: set this first
settings.file_format = 'PNG'
scene.render.filepath = "//renders/hero.png"
bpy.ops.render.render(write_still=True)

kit_tools/
├─ blender_manifest.toml
└─ __init__.py

schema_version = "1.0.0"
 
id = "kit_tools"
version = "1.0.0"
name = "Kit Tools"
tagline = "Export each collection of a modular kit"
maintainer = "Your Name <you@example.com>"
type = "add-on"
blender_version_min = "4.2.0"
license = ["SPDX:GPL-3.0-or-later"]
 
[permissions]
files = "Write glTF files next to the blend file"

import bpy
 
 
class KIT_OT_export(bpy.types.Operator):
    """Export every collection as its own GLB"""
    bl_idname = "kit.export_collections"
    bl_label = "Export Collections"
    bl_options = {'REGISTER'}
 
    folder: bpy.props.StringProperty(
        name="Folder", default="//export")
 
    def execute(self, context):
        n = export_collections(self.folder)
        self.report({'INFO'}, f"Exported {n} files")
        return {'FINISHED'}
 
 
class KIT_PT_panel(bpy.types.Panel):
    bl_label = "Kit Tools"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'          # the N sidebar
    bl_category = "Kit"            # its tab
 
    def draw(self, context):
        self.layout.operator(KIT_OT_export.bl_idname)
 
 
classes = (KIT_OT_export, KIT_PT_panel)
 
 
def register():
    for cls in classes:
        bpy.utils.register_class(cls)
 
 
def unregister():
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)

blender -b kit.blend --python-text export.py   # text block
blender -b kit.blend --python tools/export.py  # file

import random
 
import bmesh
import bpy
from mathutils import Matrix
 
rng = random.Random(7)
city = bpy.data.collections.new("City")
bpy.context.scene.collection.children.link(city)
root = bpy.data.objects.new("City_Root", None)  # empty
city.objects.link(root)
 
bm = bmesh.new()   # 1 m cube with its origin at the base
bmesh.ops.create_cube(
    bm, size=1.0, matrix=Matrix.Translation((0, 0, 0.5)))
box = bpy.data.meshes.new("Box")
bm.to_mesh(box)
bm.free()
 
LOT, STREET, N = 20.0, 10.0, 6
for i in range(N):
    for j in range(N):
        ob = bpy.data.objects.new(f"Bld_{i}_{j}", box)
        ob.parent = root
        ob.location = (i * (LOT + STREET),
                       j * (LOT + STREET), 0)
        floors = rng.randint(2, 20)
        ob.scale = (rng.uniform(12, LOT),
                    rng.uniform(12, LOT), floors * 3.0)
        city.objects.link(ob)

import bpy
 
arm = bpy.context.active_object      # the armature
assert arm and arm.type == 'ARMATURE'
for bone in arm.data.bones:
    bone.name = bone.name.removeprefix("mixamorig:")

import math
 
import bpy
from bpy_extras import anim_utils
 
def turntable(ob, frames=120):
    scene = bpy.context.scene
    scene.frame_start, scene.frame_end = 1, frames
    ob.rotation_mode = 'XYZ'
    ob.rotation_euler.z = 0.0
    ob.keyframe_insert("rotation_euler", index=2, frame=1)
    ob.rotation_euler.z = 2 * math.pi
    ob.keyframe_insert("rotation_euler", index=2,
                       frame=frames + 1)
    ad = ob.animation_data
    ad.action.name = f"{ob.name}_Turntable-loop"
    bag = anim_utils.action_get_channelbag_for_slot(
        ad.action, ad.action_slot)
    fc = bag.fcurves.find("rotation_euler", index=2)
    for kp in fc.keyframe_points:
        kp.interpolation = 'LINEAR'

import bpy
 
problems = []
for ob in bpy.data.objects:
    if ob.type != 'MESH':
        continue
    if any(abs(s - 1) > 1e-4 for s in ob.scale):
        problems.append(f"{ob.name}: unapplied scale")
    if not ob.data.materials:
        problems.append(f"{ob.name}: no material")
    if not ob.data.uv_layers:
        problems.append(f"{ob.name}: no UV map")
    tris = sum(len(p.vertices) - 2
               for p in ob.data.polygons)
    if tris > 50_000:
        problems.append(f"{ob.name}: {tris} triangles")
print("\n".join(problems) or "ok")