블렌더 아틀라스
EN
⟟ 리깅·물리

강체

Rigid Body

모양이 변하지 않는 물체의 질량·충돌·운동을 시뮬레이션한다. 움직이는 물체는 Active, 고정된 바닥은 Passive로 둔다.

다른 이름: Rigid Body Physics강체 물리
···
bpy — 이 항목
# Active 강체가 중력으로 떨어져 Passive 바닥에 부딪히고 멈추는 프레임을 시뮬레이션한다.
reset('WORKBENCH')
camera((2.2, -6.2, 9.2), target=(0, 0, 1.4), lens=54)
floor()
scene = bpy.context.scene
scene.frame_start, scene.frame_end = 1, 48

bpy.ops.mesh.primitive_cube_add(size=1, location=(0, 0, 0.08))   # 윗면이 무대 바닥(z=0)과 겹치면 줄무늬(z-fighting)가 생겨 바닥 위에 올린다
ground = bpy.context.object
ground.name = 'Passive floor'
ground.dimensions = (5.5, 4.0, 0.16)
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
paint(ground, material('Floor slab', CLAY))
bpy.ops.rigidbody.object_add(type='PASSIVE')
ground.rigid_body.collision_shape = 'BOX'

bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=20, radius=0.48, location=(0, 0, 3.2))
ball = bpy.context.object
ball.name = 'Active ball'
bpy.ops.object.shade_smooth()
paint(ball, material('Ball', LIME))
bpy.ops.rigidbody.object_add(type='ACTIVE')
ball.rigid_body.mass = 1.0
ball.rigid_body.friction = 0.72
ball.rigid_body.restitution = 0.18

world = scene.rigidbody_world
world.point_cache.frame_start, world.point_cache.frame_end = 1, 48
world.substeps_per_frame = 60
world.solver_iterations = 20
frame(ground, ball, margin=1.5)

shots = {1: 'start', 8: 'fall', 18: 'impact', 42: 'rest'}
for frame_number in range(1, 43):
    scene.frame_set(frame_number)
    bpy.context.view_layer.update()
    if frame_number in shots:
        shoot(shots[frame_number])
전체 스크립트 — Blender 5.1.1 에서 그대로 실행
# rigid-body — Blender 5.1.1 에서 그대로 돌아가는 스크립트
# 실행: blender -b --factory-startup --python rigid-body.py -- <출력 폴더>
SLUG = 'rigid-body'

# ── 무대: 모든 항목이 같이 쓰는 준비 코드 (renders/_stage.py) ──────────────────
# 빈 장면 → 렌더 엔진·크기 → 카메라·바닥·조명·재질 도우미 → shoot() 으로 WebP 저장.
import bpy, math, os, sys
from mathutils import Vector

# 출력 폴더: blender -b --factory-startup --python 이파일.py -- <출력 폴더>
OUT = sys.argv[sys.argv.index('--') + 1] if '--' in sys.argv[:-1] else os.getcwd()
os.makedirs(OUT, exist_ok=True)

# 색은 화면에서 고르는 sRGB 0~1 값으로 적는다. 블렌더 내부는 선형(linear)이라 srgb() 로 바꿔 넣는다.
BACKDROP = (0.24, 0.25, 0.27)
CLAY = (0.80, 0.77, 0.72)
LIME = (0.64, 0.90, 0.21)
SKY = (0.22, 0.65, 0.95)
CORAL = (0.96, 0.42, 0.45)
INK = (0.08, 0.09, 0.10)
ENGINES = {'WORKBENCH': 'BLENDER_WORKBENCH', 'EEVEE': 'BLENDER_EEVEE', 'CYCLES': 'CYCLES'}


def srgb(c, alpha=1.0):
    lin = lambda v: v / 12.92 if v <= 0.04045 else ((v + 0.055) / 1.055) ** 2.4
    return (lin(c[0]), lin(c[1]), lin(c[2]), alpha)


def reset(engine='WORKBENCH', samples=16, size=(960, 600)):
    """빈 장면에서 시작한다. engine: WORKBENCH(모양 확인) · EEVEE(실시간) · CYCLES(경로 추적)."""
    bpy.ops.wm.read_factory_settings(use_empty=True)
    sc = bpy.context.scene
    sc.render.engine = ENGINES[engine]
    sc.render.resolution_x, sc.render.resolution_y = size
    sc.render.resolution_percentage = 100
    sc.render.image_settings.file_format = 'WEBP'
    sc.render.image_settings.quality = 82
    sc.world = bpy.data.worlds.new('World')
    world_color(BACKDROP)
    if engine == 'WORKBENCH':
        sh = sc.display.shading
        sh.light, sh.color_type = 'STUDIO', 'MATERIAL'
        sh.show_shadows, sh.shadow_intensity = True, 0.35
        sh.show_cavity = True
        sc.display.render_aa = '16'
        sc.view_settings.view_transform = 'Standard'  # 재질 색을 그대로 보여 준다
    elif engine == 'EEVEE':
        sc.eevee.taa_render_samples = samples
    else:
        sc.cycles.samples = samples
        sc.cycles.use_denoising = True
    return sc


def world_color(color, strength=1.0):
    """배경색. Workbench 는 world.color, EEVEE·Cycles 는 Background 노드를 쓴다."""
    w = bpy.context.scene.world
    w.color = srgb(color)[:3]
    bg = w.node_tree.nodes.get('Background') if w.node_tree else None
    if bg:
        bg.inputs['Color'].default_value = srgb(color)
        bg.inputs['Strength'].default_value = strength
    return w


def hdri(name='studio', strength=1.0, show=False):
    """블렌더에 들어 있는 HDRI 로 장면을 비춘다(CC0 · Poly Haven). name: studio · city · courtyard · forest · interior · night · sunrise · sunset.
    show=False 면 빛과 반사에만 쓰고, 카메라에는 BACKDROP 색 배경이 보인다(Light Path 의 Is Camera Ray 로 가른다)."""
    nt = bpy.context.scene.world.node_tree
    nodes, links = nt.nodes, nt.links
    env = nodes.new('ShaderNodeTexEnvironment')
    env.image = bpy.data.images.load(os.path.join(bpy.utils.system_resource('DATAFILES'), 'studiolights', 'world', f'{name}.exr'))
    bg = nodes['Background']
    bg.inputs['Strength'].default_value = strength
    links.new(env.outputs['Color'], bg.inputs['Color'])
    if not show:
        flat = nodes.new('ShaderNodeBackground')
        flat.inputs['Color'].default_value = srgb(BACKDROP)
        ray, mix = nodes.new('ShaderNodeLightPath'), nodes.new('ShaderNodeMixShader')
        links.new(ray.outputs['Is Camera Ray'], mix.inputs['Fac'])
        links.new(bg.outputs['Background'], mix.inputs[1])
        links.new(flat.outputs['Background'], mix.inputs[2])
        links.new(mix.outputs['Shader'], nodes['World Output'].inputs['Surface'])
    return env


def look_at(obj, target):
    obj.rotation_euler = (Vector(target) - obj.location).to_track_quat('-Z', 'Y').to_euler()


def camera(location=(7, -7, 5), target=(0, 0, 0.5), lens=50):
    cam = bpy.data.objects.new('Camera', bpy.data.cameras.new('Camera'))
    bpy.context.scene.collection.objects.link(cam)
    cam.location = location
    look_at(cam, target)
    cam.data.lens = lens
    bpy.context.scene.camera = cam
    return cam


def frame(*objs, margin=1.15):
    """카메라 방향은 그대로 두고, objs 가 화면에 다 들어오게 카메라를 앞뒤로 옮긴다."""
    sc = bpy.context.scene
    dg = bpy.context.evaluated_depsgraph_get()
    pts = [o.matrix_world @ Vector(c) for o in objs for c in o.evaluated_get(dg).bound_box]
    mid = sum(pts, Vector()) / len(pts)
    coords = [c for p in pts for c in (mid + (p - mid) * margin)]
    loc, _scale = sc.camera.camera_fit_coords(dg, coords)
    sc.camera.location = loc
    return sc.camera


def light(kind='AREA', location=(4, -4, 6), target=(0, 0, 0), energy=600, size=3.0, color=(1, 1, 1)):
    """kind: POINT · SUN · SPOT · AREA. energy 는 와트(SUN 은 W/m²에 해당하는 세기)."""
    data = bpy.data.lights.new(kind.title(), kind)
    data.energy, data.color = energy, color
    if kind == 'AREA':
        data.size = size
    obj = bpy.data.objects.new(data.name, data)
    bpy.context.scene.collection.objects.link(obj)
    obj.location = location
    look_at(obj, target)
    return obj


def studio(key=700, fill=200, rim=450):
    """기본 3점 조명(키·필·림). EEVEE·Cycles 용 — Workbench 는 자체 스튜디오 조명을 쓴다."""
    return [light('AREA', (5, -4, 6), energy=key, size=4),
            light('AREA', (-6, -3, 3), energy=fill, size=5),
            light('AREA', (0, 6, 5), energy=rim, size=3)]


def material(name, color=CLAY, roughness=0.5, metallic=0.0, **inputs):
    """원리 BSDF 재질. inputs 는 소켓 이름(공백은 _ 로): Emission_Strength=3."""
    mat = bpy.data.materials.new(name)
    mat.diffuse_color = srgb(color)  # Workbench 가 보는 색
    bsdf = mat.node_tree.nodes['Principled BSDF']
    bsdf.inputs['Base Color'].default_value = srgb(color)
    bsdf.inputs['Roughness'].default_value = roughness
    bsdf.inputs['Metallic'].default_value = metallic
    for key, value in inputs.items():
        bsdf.inputs[key.replace('_', ' ')].default_value = value
    return mat


def paint(obj, mat):
    obj.data.materials.clear()
    obj.data.materials.append(mat)
    return obj


def floor(size=80.0, color=None, z=0.0, wall=30.0, curve=6.0):
    """바닥과 뒷벽(+Y 쪽)이 둥글게 이어진 스튜디오 배경 — 지평선이 보이지 않는다. 카메라는 -Y 쪽에서 +Y 를 보게 둔다."""
    import bmesh
    back = size / 2
    steps = 12
    profile = [(-back, 0.0)]  # (y, z) 단면: 앞 → 둥근 모서리 → 벽 위
    for i in range(steps + 1):
        a = (math.pi / 2) * i / steps
        profile.append((back - curve + curve * math.sin(a), curve - curve * math.cos(a)))
    profile.append((back, wall))
    bm = bmesh.new()
    left = [bm.verts.new((-back, y, z + h)) for y, h in profile]
    right = [bm.verts.new((back, y, z + h)) for y, h in profile]
    for i in range(len(profile) - 1):
        bm.faces.new((left[i], right[i], right[i + 1], left[i + 1]))
    me = bpy.data.meshes.new('Floor')
    bm.to_mesh(me)
    bm.free()
    obj = bpy.data.objects.new('Floor', me)
    bpy.context.scene.collection.objects.link(obj)
    for poly in me.polygons:
        poly.use_smooth = True
    return paint(obj, material('Floor', color or BACKDROP, roughness=0.9))


def edges(obj, thickness=0.012, color=INK):
    """메시의 선(엣지)을 렌더에 보이게 한다 — 모디파이어까지 적용된 모양에 와이어프레임을 씌운 복제본."""
    dg = bpy.context.evaluated_depsgraph_get()
    wire = bpy.data.objects.new(obj.name + '.edges', bpy.data.meshes.new_from_object(obj.evaluated_get(dg)))
    bpy.context.scene.collection.objects.link(wire)
    wire.matrix_world = obj.matrix_world.copy()
    mod = wire.modifiers.new('Wireframe', 'WIREFRAME')
    mod.thickness, mod.use_even_offset = thickness, True
    return paint(wire, material(obj.name + '.edges', color, roughness=0.8))


def shoot(name):
    """지금 장면을 <출력 폴더>/<항목>-<name>.webp 로 렌더한다."""
    sc = bpy.context.scene
    sc.render.filepath = os.path.join(OUT, f'{SLUG}-{name}.webp')
    bpy.ops.render.render(write_still=True)
    return sc.render.filepath


# ── 이 항목 ──
# Active 강체가 중력으로 떨어져 Passive 바닥에 부딪히고 멈추는 프레임을 시뮬레이션한다.
reset('WORKBENCH')
camera((2.2, -6.2, 9.2), target=(0, 0, 1.4), lens=54)
floor()
scene = bpy.context.scene
scene.frame_start, scene.frame_end = 1, 48

bpy.ops.mesh.primitive_cube_add(size=1, location=(0, 0, 0.08))   # 윗면이 무대 바닥(z=0)과 겹치면 줄무늬(z-fighting)가 생겨 바닥 위에 올린다
ground = bpy.context.object
ground.name = 'Passive floor'
ground.dimensions = (5.5, 4.0, 0.16)
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
paint(ground, material('Floor slab', CLAY))
bpy.ops.rigidbody.object_add(type='PASSIVE')
ground.rigid_body.collision_shape = 'BOX'

bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=20, radius=0.48, location=(0, 0, 3.2))
ball = bpy.context.object
ball.name = 'Active ball'
bpy.ops.object.shade_smooth()
paint(ball, material('Ball', LIME))
bpy.ops.rigidbody.object_add(type='ACTIVE')
ball.rigid_body.mass = 1.0
ball.rigid_body.friction = 0.72
ball.rigid_body.restitution = 0.18

world = scene.rigidbody_world
world.point_cache.frame_start, world.point_cache.frame_end = 1, 48
world.substeps_per_frame = 60
world.solver_iterations = 20
frame(ground, ball, margin=1.5)

shots = {1: 'start', 8: 'fall', 18: 'impact', 42: 'rest'}
for frame_number in range(1, 43):
    scene.frame_set(frame_number)
    bpy.context.view_layer.update()
    if frame_number in shots:
        shoot(shots[frame_number])
···

충돌Collision

메시를 천·소프트 바디·파티클 등이 부딪힐 표면으로 등록한다. 충돌 설정은 시뮬레이션이 그 표면을 어떻게 통과·감쇠하는지 정한다.

···

소프트 바디Soft Body

메시의 정점이 스프링처럼 연결된 상태로 움직이며 표면이 휘고 튕기는 물리 시뮬레이션. 목표 그룹으로 원래 형태를 붙잡을 수 있다.

···

천 시뮬레이션Cloth

메시를 천처럼 시뮬레이션해 중력·바람·충돌에 따라 접히고 늘어지게 한다. 핀 그룹으로 고정할 정점을 지정한다.

···

파티클 시스템Particle System

이미터에서 작은 입자를 시간에 따라 방출하고 이동·수명·렌더 모양을 계산한다. 렌더 방식은 엔진에 따라 다르며, Cycles는 Object와 Collection만 지원한다.

강체는 단단한 블록을 밀고 떨어뜨리는 것처럼, 물체의 모양은 유지하고 위치와 회전만 계산한다. Object ▸ Rigid Body ▸ Add Active로 움직이는 물체를, Add Passive로 바닥이나 벽을 등록한다. Physics Properties의 Mass·Friction·Collision Shape가 운동과 충돌을 바꾼다.

스크립트에서는 bpy.ops.rigidbody.object_add(type='ACTIVE') 또는 'PASSIVE'로 월드에 등록한 뒤 object.rigid_body의 mass, friction, collision_shape를 설정한다. 장면에는 RigidBodyWorld가 필요하고, 시뮬레이션 결과는 프레임 캐시에 저장된다. 렌더마다 같은 결과를 얻으려면 시작 프레임과 캐시 범위를 고정한다.

동적 스케일 조절이 필요 없다면 Ctrl+A ▸ Scale로 오브젝트 스케일을 적용한다. 시뮬레이션은 시작 프레임부터 순서대로 재생해 계산하고, 데모는 강체 공이 바닥에 떨어져 정지하는 프레임을 재생한다.

언제 쓰나

구슬·블록·기계 부품처럼 변형되지 않는 물체의 충돌과 낙하를 만들 때 쓴다. 찌그러지는 물체는 소프트 바디, 천은 Cloth를 고른다.

페이지로 열기 ↗

항목 추가 요청

아틀라스에 없는 블렌더 용어·도구·작업 흐름을 알려 주세요. 하나씩 보고 추가합니다.