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

파티클 시스템

Particle System

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

다른 이름: ParticlesParticleSettings파티클
···
bpy — 이 항목
# 실제 이미터에서 입자 인스턴스를 방출하고 프레임별로 평가해 파티클의 수명과 이동을 보여 준다.
reset('WORKBENCH', size=(640, 400))
camera((5.5, -8.5, 5.2), target=(0, 0, 1.65), lens=52)
floor()
scene = bpy.context.scene
scene.frame_start, scene.frame_end = 1, 40

bpy.ops.mesh.primitive_plane_add(size=1.35, location=(0, 0, 0.25))
emitter = bpy.context.object
emitter.name = 'Particle emitter'
paint(emitter, material('Emitter', CLAY))

bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=1, radius=0.11, location=(30, 0, 0))
instance = bpy.context.object
instance.name = 'Particle instance'
paint(instance, material('Particle', LIME))
bpy.ops.object.select_all(action='DESELECT')
emitter.select_set(True)
bpy.context.view_layer.objects.active = emitter
bpy.ops.object.particle_system_add()
settings = emitter.particle_systems[-1].settings
settings.count = 180
settings.frame_start, settings.frame_end = 1, 24
settings.lifetime = 30
settings.normal_factor = 2.4
settings.factor_random = 0.35
settings.particle_size = 0.8
settings.size_random = 0.25
settings.render_type = 'OBJECT'
settings.instance_object = instance
settings.use_rotations = True

frame(emitter, margin=1.6)
shots = {8: 'p08', 16: 'p16', 24: 'p24', 32: 'p32'}
for frame_number in range(1, 33):
    scene.frame_set(frame_number)
    bpy.context.view_layer.update()
    if frame_number in shots:
        shoot(shots[frame_number])
전체 스크립트 — Blender 5.1.1 에서 그대로 실행
# particle-system — Blender 5.1.1 에서 그대로 돌아가는 스크립트
# 실행: blender -b --factory-startup --python particle-system.py -- <출력 폴더>
SLUG = 'particle-system'

# ── 무대: 모든 항목이 같이 쓰는 준비 코드 (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


# ── 이 항목 ──
# 실제 이미터에서 입자 인스턴스를 방출하고 프레임별로 평가해 파티클의 수명과 이동을 보여 준다.
reset('WORKBENCH', size=(640, 400))
camera((5.5, -8.5, 5.2), target=(0, 0, 1.65), lens=52)
floor()
scene = bpy.context.scene
scene.frame_start, scene.frame_end = 1, 40

bpy.ops.mesh.primitive_plane_add(size=1.35, location=(0, 0, 0.25))
emitter = bpy.context.object
emitter.name = 'Particle emitter'
paint(emitter, material('Emitter', CLAY))

bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=1, radius=0.11, location=(30, 0, 0))
instance = bpy.context.object
instance.name = 'Particle instance'
paint(instance, material('Particle', LIME))
bpy.ops.object.select_all(action='DESELECT')
emitter.select_set(True)
bpy.context.view_layer.objects.active = emitter
bpy.ops.object.particle_system_add()
settings = emitter.particle_systems[-1].settings
settings.count = 180
settings.frame_start, settings.frame_end = 1, 24
settings.lifetime = 30
settings.normal_factor = 2.4
settings.factor_random = 0.35
settings.particle_size = 0.8
settings.size_random = 0.25
settings.render_type = 'OBJECT'
settings.instance_object = instance
settings.use_rotations = True

frame(emitter, margin=1.6)
shots = {8: 'p08', 16: 'p16', 24: 'p24', 32: 'p32'}
for frame_number in range(1, 33):
    scene.frame_set(frame_number)
    bpy.context.view_layer.update()
    if frame_number in shots:
        shoot(shots[frame_number])
···

힘 필드Force Field

파티클·천·소프트 바디 같은 시뮬레이션에 외부 힘을 더하는 오브젝트. 바람·와류·자기력·난류 등 종류에 따라 방향과 반응이 달라진다.

···

충돌Collision

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

···

강체Rigid Body

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

···

소프트 바디Soft Body

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

파티클 시스템은 씨앗을 뿌리듯 한 오브젝트에서 많은 입자를 만들어 시간에 따라 흩어지게 한다. 이미터 메시를 선택해 Particle Properties에서 시스템을 추가하고, Count·Frame Start/End·Lifetime·Velocity를 조절한다. Particle System ▸ Render에서 렌더 유형을 정한다. 지원 유형은 엔진마다 다르고, Cycles에서는 Object와 Collection만 쓸 수 있다.

코드에서는 오브젝트에 파티클 시스템을 추가한 뒤 ParticleSettings의 count, frame_start, lifetime, normal_factor와 render_type을 설정한다. 입자는 프레임 평가와 캐시에 의존하므로 장면의 프레임 범위를 고정하고 순서대로 계산해야 한다. 작은 오브젝트를 인스턴스로 쓰면 매 입자마다 메시를 복제하지 않고 반복 배치할 수 있다.

이미터의 노멀 방향과 속도가 바뀌면 분포가 크게 달라지고, 너무 많은 입자는 렌더 시간을 늘린다. 데모는 이미터에서 방출된 실제 오브젝트 인스턴스가 퍼지는 모습을 프레임별로 보여 준다.

언제 쓰나

먼지·불꽃·씨앗처럼 개별 물체가 많이 흩어지는 효과에 쓴다. 입자 수와 수명을 먼저 낮은 값으로 확인하고, 필요하면 인스턴스 오브젝트로 표현한다.

페이지로 열기 ↗

항목 추가 요청

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