Godot 4 में GPUParticles2D/3D — संपूर्ण गाइड

1. परिचय

Godot 4 डिफ़ॉल्ट पार्टिकल सिस्टम नोड्स के रूप में GPUParticles2D और GPUParticles3D का उपयोग करता है। ये पूरी तरह GPU पर चलते हैं, जिससे बड़ी पार्टिकल संख्या के लिए ये अपने CPU समकक्षों की तुलना में काफी तेज़ होते हैं। Godot 3 का पुराना ParticlesMaterial अब ParticleProcessMaterial से बदल दिया गया है, जो पार्टिकल के व्यवहार पर अधिक नियंत्रण देता है।

CPUParticles2D और CPUParticles3D उन डिवाइसों के लिए फ़ॉलबैक नोड्स के रूप में अब भी मौजूद हैं जिनमें GPU कंप्यूट सपोर्ट नहीं है, या जब आपको GDScript से अलग-अलग पार्टिकल डेटा तक पहुँच चाहिए। ज़्यादातर मामलों में GPU पार्टिकल ही अनुशंसित विकल्प हैं।

2. GPUParticles2D बनाम CPUParticles2D

3. बुनियादी सेटअप

एक बुनियादी पार्टिकल इफ़ेक्ट बनाने के लिए, अपने सीन में एक GPUParticles2D नोड जोड़ें और उसे एक ParticleProcessMaterial असाइन करें। GDScript में एक न्यूनतम सेटअप यहाँ दिया गया है:

# Create a GPUParticles2D node via code
var particles = GPUParticles2D.new()
particles.amount = 50
particles.lifetime = 2.0
particles.explosiveness = 0.0  # 0 = continuous, 1 = all at once
particles.randomness = 0.5

# Create and assign the material
var mat = ParticleProcessMaterial.new()
mat.direction = Vector3(0, -1, 0)  # Note: uses Vector3 even in 2D
mat.initial_velocity_min = 50.0
mat.initial_velocity_max = 100.0
mat.gravity = Vector3(0, 98, 0)

particles.process_material = mat
add_child(particles)

GPUParticles2D नोड की स्वयं की महत्वपूर्ण प्रॉपर्टीज़:

• amount — किसी भी समय जीवित पार्टिकल की संख्या (डिफ़ॉल्ट: 8)
• lifetime — प्रत्येक पार्टिकल कितने सेकंड जीवित रहता है (डिफ़ॉल्ट: 1.0)
• one_shot — एक बार एमिट करें फिर रुक जाएँ (डिफ़ॉल्ट: false)
• explosiveness — 0.0 = निरंतर धारा, 1.0 = सभी पार्टिकल एक साथ
• randomness — एमिशन टाइमिंग में यादृच्छिक ऑफ़सेट (0.0-1.0)
• speed_scale — सिमुलेशन गति का गुणक
• emitting — क्या सिस्टम वर्तमान में एमिट कर रहा है

4. ParticleProcessMaterial विस्तार से

ParticleProcessMaterial यह नियंत्रित करता है कि अलग-अलग पार्टिकल अपने जीवनकाल में कैसे व्यवहार करते हैं। सभी दिशात्मक प्रॉपर्टीज़ Vector3 का उपयोग करती हैं, भले ही 2D पार्टिकल हों (Z कंपोनेंट को बस अनदेखा कर दिया जाता है)।

दिशा एवं गति

var mat = ParticleProcessMaterial.new()

# Direction: normalized vector for initial particle heading
mat.direction = Vector3(0, -1, 0)  # Upward in 2D (Y is flipped)

# Spread: cone angle in degrees (0 = straight line, 180 = hemisphere)
mat.spread = 45.0

# Initial velocity: particles spawn with speed in this range
mat.initial_velocity_min = 100.0
mat.initial_velocity_max = 200.0

# Gravity: constant acceleration applied every frame
mat.gravity = Vector3(0, 98, 0)  # Pulls downward in 2D

कोणीय गति

पार्टिकल को चलते समय घुमाता है। मलबे, कॉन्फ़ेटी या पत्तियों के लिए उपयोगी।

mat.angular_velocity_min = -180.0  # degrees per second
mat.angular_velocity_max = 180.0

जीवनकाल में स्केल परिवर्तन

पार्टिकल के आकार को उसके जीवनकाल में बदलने के लिए एक CurveTexture का उपयोग करें:

var curve = Curve.new()
curve.add_point(Vector2(0.0, 1.0))  # Full size at birth
curve.add_point(Vector2(0.5, 1.2))  # Slightly larger at midlife
curve.add_point(Vector2(1.0, 0.0))  # Shrink to nothing at death

var curve_tex = CurveTexture.new()
curve_tex.curve = curve
mat.scale_curve = curve_tex

डैम्पिंग एवं अट्रैक्टर

डैम्पिंग समय के साथ पार्टिकल को धीमा करता है, जिससे वायु प्रतिरोध का अनुकरण होता है। अट्रैक्टर (अलग नोड्स) पार्टिकल को किसी बिंदु की ओर खींचते हैं।

mat.damping_min = 5.0
mat.damping_max = 10.0

5. कलर ग्रेडिएंट

ParticleProcessMaterial पर color_ramp प्रॉपर्टी एक GradientTexture1D स्वीकार करती है, जिससे पार्टिकल का रंग उसके जीवनकाल में सहजता से बदलता है। यह यथार्थवादी आग, धुआं और जादू के इफ़ेक्ट के लिए अनिवार्य है।

उदाहरण: आग का ग्रेडिएंट

var gradient = Gradient.new()
gradient.colors = PackedColorArray([
    Color(1.0, 1.0, 1.0, 1.0),    # White (hot core)
    Color(1.0, 1.0, 0.2, 1.0),    # Yellow
    Color(1.0, 0.5, 0.0, 1.0),    # Orange
    Color(0.8, 0.1, 0.0, 0.8),    # Red
    Color(0.2, 0.0, 0.0, 0.0),    # Dark red, transparent (fade out)
])
gradient.offsets = PackedFloat32Array([0.0, 0.15, 0.4, 0.7, 1.0])

var grad_tex = GradientTexture1D.new()
grad_tex.gradient = gradient
mat.color_ramp = grad_tex

एक समान रंग वाले पार्टिकल के लिए, आप ग्रेडिएंट के बजाय एक सपाट color प्रॉपर्टी भी सेट कर सकते हैं:

mat.color = Color(0.2, 0.6, 1.0, 0.8)  # Semi-transparent blue

6. एमिशन शेप्स

एमिशन शेप यह निर्धारित करता है कि पार्टिकल कहाँ उत्पन्न होते हैं। इसे ParticleProcessMaterial पर emission_shape के माध्यम से सेट किया जाता है।

Point

सभी पार्टिकल नोड के मूल बिंदु (origin) पर उत्पन्न होते हैं। यह डिफ़ॉल्ट शेप है।

mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_POINT

Sphere / Sphere Surface

पार्टिकल एक गोले के भीतर (या केवल उसकी सतह पर) यादृच्छिक रूप से उत्पन्न होते हैं।

mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_SPHERE
mat.emission_sphere_radius = 50.0

# Surface only:
mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_SPHERE_SURFACE
mat.emission_sphere_radius = 50.0

Box

पार्टिकल एक आयताकार आयतन के भीतर यादृच्छिक रूप से उत्पन्न होते हैं।

mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_BOX
mat.emission_box_extents = Vector3(100, 10, 0)  # Wide and thin

Ring

पार्टिकल एक रिंग (डोनट) आकार में उत्पन्न होते हैं, जिसे आंतरिक/बाहरी त्रिज्या और ऊँचाई से परिभाषित किया जाता है।

mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_RING
mat.emission_ring_radius = 80.0       # Outer radius
mat.emission_ring_inner_radius = 60.0 # Inner radius (hole)
mat.emission_ring_height = 0.0        # Flat ring
mat.emission_ring_axis = Vector3(0, 0, 1)  # Ring normal

7. व्यावहारिक रेसिपी

आग

नारंगी-लाल ग्रेडिएंट, ऊपर की ओर गति, हल्का फैलाव, जीवनकाल में घटता हुआ स्केल।

func create_fire() -> GPUParticles2D:
    var p = GPUParticles2D.new()
    p.amount = 40
    p.lifetime = 0.8
    p.randomness = 0.3

    var mat = ParticleProcessMaterial.new()
    mat.direction = Vector3(0, -1, 0)
    mat.spread = 15.0
    mat.initial_velocity_min = 40.0
    mat.initial_velocity_max = 80.0
    mat.gravity = Vector3(0, -20, 0)  # Slight upward pull
    mat.damping_min = 5.0
    mat.damping_max = 10.0

    # Color ramp: white -> yellow -> orange -> red -> transparent
    var grad = Gradient.new()
    grad.colors = PackedColorArray([
        Color(1, 1, 1, 1), Color(1, 1, 0.2, 1),
        Color(1, 0.4, 0, 0.9), Color(0.6, 0.1, 0, 0.4),
        Color(0.2, 0, 0, 0)
    ])
    grad.offsets = PackedFloat32Array([0.0, 0.1, 0.35, 0.7, 1.0])
    var grad_tex = GradientTexture1D.new()
    grad_tex.gradient = grad
    mat.color_ramp = grad_tex

    # Scale: shrink over time
    var curve = Curve.new()
    curve.add_point(Vector2(0, 0.8))
    curve.add_point(Vector2(0.3, 1.0))
    curve.add_point(Vector2(1, 0.0))
    var curve_tex = CurveTexture.new()
    curve_tex.curve = curve
    mat.scale_curve = curve_tex

    p.process_material = mat
    return p

धुआं

ग्रे ग्रेडिएंट, धीमी ऊपर की ओर गति, बड़ा फैलाव, धुंधले रूप के लिए कम अल्फा।

func create_smoke() -> GPUParticles2D:
    var p = GPUParticles2D.new()
    p.amount = 25
    p.lifetime = 3.0
    p.randomness = 0.5

    var mat = ParticleProcessMaterial.new()
    mat.direction = Vector3(0, -1, 0)
    mat.spread = 35.0
    mat.initial_velocity_min = 10.0
    mat.initial_velocity_max = 30.0
    mat.gravity = Vector3(0, -5, 0)
    mat.damping_min = 2.0
    mat.damping_max = 5.0
    mat.angular_velocity_min = -30.0
    mat.angular_velocity_max = 30.0

    var grad = Gradient.new()
    grad.colors = PackedColorArray([
        Color(0.6, 0.6, 0.6, 0.0), Color(0.5, 0.5, 0.5, 0.3),
        Color(0.4, 0.4, 0.4, 0.2), Color(0.3, 0.3, 0.3, 0.0)
    ])
    grad.offsets = PackedFloat32Array([0.0, 0.15, 0.6, 1.0])
    var grad_tex = GradientTexture1D.new()
    grad_tex.gradient = grad
    mat.color_ramp = grad_tex

    # Scale: grow over time (smoke expands)
    var curve = Curve.new()
    curve.add_point(Vector2(0, 0.3))
    curve.add_point(Vector2(0.5, 1.0))
    curve.add_point(Vector2(1, 1.5))
    var curve_tex = CurveTexture.new()
    curve_tex.curve = curve
    mat.scale_curve = curve_tex

    p.process_material = mat
    return p

बारिश

नीले-सफ़ेद लकीरें, तेज़ नीचे की ओर गुरुत्वाकर्षण, संकरा फैलाव, अधिक पार्टिकल संख्या।

func create_rain() -> GPUParticles2D:
    var p = GPUParticles2D.new()
    p.amount = 200
    p.lifetime = 1.0

    # Use a box emission to cover the screen width
    var mat = ParticleProcessMaterial.new()
    mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_BOX
    mat.emission_box_extents = Vector3(600, 0, 0)
    mat.direction = Vector3(0.05, 1, 0)  # Slightly angled
    mat.spread = 3.0
    mat.initial_velocity_min = 400.0
    mat.initial_velocity_max = 500.0
    mat.gravity = Vector3(0, 200, 0)

    var grad = Gradient.new()
    grad.colors = PackedColorArray([
        Color(0.7, 0.8, 1.0, 0.6), Color(0.7, 0.85, 1.0, 0.4),
        Color(0.7, 0.85, 1.0, 0.0)
    ])
    grad.offsets = PackedFloat32Array([0.0, 0.8, 1.0])
    var grad_tex = GradientTexture1D.new()
    grad_tex.gradient = grad
    mat.color_ramp = grad_tex

    # Stretch particles to look like streaks
    mat.scale_min = 0.5
    mat.scale_max = 0.5

    p.process_material = mat
    return p

चिंगारी

पीला-नारंगी, विस्फोटक फुहार, अधिक प्रारंभिक गति, छोटा जीवनकाल।

func create_sparks() -> GPUParticles2D:
    var p = GPUParticles2D.new()
    p.amount = 30
    p.lifetime = 0.5
    p.one_shot = true
    p.explosiveness = 1.0  # All at once

    var mat = ParticleProcessMaterial.new()
    mat.direction = Vector3(0, -1, 0)
    mat.spread = 180.0  # Full sphere
    mat.initial_velocity_min = 150.0
    mat.initial_velocity_max = 300.0
    mat.gravity = Vector3(0, 200, 0)  # Fall quickly
    mat.damping_min = 10.0
    mat.damping_max = 20.0

    var grad = Gradient.new()
    grad.colors = PackedColorArray([
        Color(1, 1, 0.8, 1), Color(1, 0.7, 0.1, 1),
        Color(1, 0.3, 0, 0.5), Color(0.5, 0.1, 0, 0)
    ])
    grad.offsets = PackedFloat32Array([0.0, 0.2, 0.6, 1.0])
    var grad_tex = GradientTexture1D.new()
    grad_tex.gradient = grad
    mat.color_ramp = grad_tex

    # Scale: start small, stay small
    mat.scale_min = 0.3
    mat.scale_max = 0.6

    p.process_material = mat
    return p

बर्फ

सफ़ेद पार्टिकल, धीमा कोमल अवतरण, चौड़ा फैलाव, हल्की क्षैतिज बहाव।

func create_snow() -> GPUParticles2D:
    var p = GPUParticles2D.new()
    p.amount = 100
    p.lifetime = 5.0
    p.randomness = 0.8

    var mat = ParticleProcessMaterial.new()
    mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_BOX
    mat.emission_box_extents = Vector3(500, 0, 0)
    mat.direction = Vector3(0.1, 1, 0)
    mat.spread = 10.0
    mat.initial_velocity_min = 20.0
    mat.initial_velocity_max = 40.0
    mat.gravity = Vector3(0, 10, 0)
    mat.damping_min = 1.0
    mat.damping_max = 3.0
    mat.angular_velocity_min = -45.0
    mat.angular_velocity_max = 45.0

    var grad = Gradient.new()
    grad.colors = PackedColorArray([
        Color(1, 1, 1, 0), Color(1, 1, 1, 0.8),
        Color(1, 1, 1, 0.7), Color(1, 1, 1, 0)
    ])
    grad.offsets = PackedFloat32Array([0.0, 0.05, 0.8, 1.0])
    var grad_tex = GradientTexture1D.new()
    grad_tex.gradient = grad
    mat.color_ramp = grad_tex

    mat.scale_min = 0.3
    mat.scale_max = 0.8

    p.process_material = mat
    return p

8. 3D पार्टिकल (GPUParticles3D)

GPUParticles3D GPUParticles2D के समान ही काम करता है, लेकिन 3D स्पेस में संचालित होता है। यह वही ParticleProcessMaterial उपयोग करता है। मुख्य अंतर:

• Vector3 के तीनों अक्ष सक्रिय होते हैं (X, Y, Z)
• एमिशन शेप्स पूर्ण 3D में काम करते हैं (गोले असली गोले होते हैं, बॉक्स आयतन होते हैं)
• बिलबोर्ड पार्टिकल के लिए आप draw_pass_1 को एक QuadMesh या कस्टम मेश के साथ उपयोग कर सकते हैं
• मेश पार्टिकल StandardMaterial3D या ORMMaterial3D का उपयोग कर सकते हैं

# 3D fire torch example
var particles_3d = GPUParticles3D.new()
particles_3d.amount = 60
particles_3d.lifetime = 1.0

var mat = ParticleProcessMaterial.new()
mat.direction = Vector3(0, 1, 0)  # Upward in 3D
mat.spread = 20.0
mat.initial_velocity_min = 1.0
mat.initial_velocity_max = 2.0
mat.gravity = Vector3(0, -0.5, 0)  # Slight counter-gravity

# Emission from a small sphere
mat.emission_shape = ParticleProcessMaterial.EMISSION_SHAPE_SPHERE
mat.emission_sphere_radius = 0.2

particles_3d.process_material = mat

# Use a QuadMesh as the particle shape
var quad = QuadMesh.new()
quad.size = Vector2(0.3, 0.3)
particles_3d.draw_pass_1 = quad

# Billboard mode: particles always face the camera
mat.billboard_mode = BaseMaterial3D.BILLBOARD_ENABLED

add_child(particles_3d)

9. सब-एमिटर

Godot 4 पार्टिकल-पर-पार्टिकल इफ़ेक्ट के लिए सब-एमिटर का समर्थन करता है। एक सब-एमिटर एक और GPUParticles2D/GPUParticles3D नोड होता है, जो प्रत्येक मूल पार्टिकल की स्थिति पर पार्टिकल एमिट करता है। यह इनके लिए आदर्श है:

• आग के पार्टिकल से उड़ती चिंगारियाँ
• आतिशबाजी के विस्फोट के पीछे धुएं के निशान
• टकराव पर छींटे की बूँदें
• द्वितीयक विस्फोट

सब-एमिटर को इस प्रकार सेट करें:

# 1. Create the sub-emitter node (must be a sibling or child)
var sub_sparks = GPUParticles2D.new()
sub_sparks.amount = 4
sub_sparks.lifetime = 0.3
sub_sparks.explosiveness = 1.0
sub_sparks.emitting = false  # Controlled by parent
var sub_mat = ParticleProcessMaterial.new()
sub_mat.direction = Vector3(0, -1, 0)
sub_mat.spread = 180.0
sub_mat.initial_velocity_min = 50.0
sub_mat.initial_velocity_max = 100.0
sub_sparks.process_material = sub_mat
add_child(sub_sparks)

# 2. Reference it from the parent material
var parent_mat: ParticleProcessMaterial = fire_particles.process_material
parent_mat.sub_emitter_mode = ParticleProcessMaterial.SUB_EMITTER_AT_END
# Also: SUB_EMITTER_AT_COLLISION, SUB_EMITTER_CONSTANT

# 3. Set the sub_emitter property on the parent node
fire_particles.sub_emitter = fire_particles.get_path_to(sub_sparks)

सब-एमिटर मोड्स:

• SUB_EMITTER_CONSTANT — प्रत्येक मूल पार्टिकल से निरंतर एमिट करता है
• SUB_EMITTER_AT_END — जब मूल पार्टिकल मरता है तब एमिट करता है
• SUB_EMITTER_AT_COLLISION — जब मूल पार्टिकल टकराता है तब एमिट करता है

10. परफॉर्मेंस टिप्स

• संख्या बनाम जीवनकाल का संतुलन: कुल दृश्यमान पार्टिकल = amount. यदि आप lifetime बढ़ाते हैं, तो पार्टिकल अधिक देर तक जमा होते हैं। संतुलन के लिए amount घटाएँ, या सघन इफ़ेक्ट के लिए बढ़ाएँ।
• Visibility Range का उपयोग करें (3D): GPUParticles3D पर visibility_range_end सेट करें, ताकि दूर के पार्टिकल सिस्टम रेंडर होना बंद कर दें। ओपन-वर्ल्ड के लिए यह एक बड़ा लाभ है।
• फ़िक्स्ड FPS: सिमुलेशन अपडेट को सीमित करने के लिए पार्टिकल नोड पर fixed_fps सेट करें (जैसे 30)। पार्टिकल फिर भी सहजता से इंटरपोलेट होते हैं, लेकिन कम GPU समय लेते हैं।
• फुहारों के लिए One-Shot: विस्फोट जैसे इफ़ेक्ट के लिए one_shot = true को explosiveness = 1.0 के साथ उपयोग करें। जीवनकाल समाप्त होने के बाद नोड को मुक्त किया जा सकता है।
• 3D के लिए LOD उपयोग करें: Level-of-Detail (LOD) पार्टिकल इफ़ेक्ट के लिए visibility_range_begin/end को विभिन्न विवरण स्तरों पर कई पार्टिकल नोड्स के साथ मिलाएँ।
• ओवरड्रॉ से बचें: कई अर्ध-पारदर्शी पार्टिकल एक-दूसरे पर ओवरलैप होना = महँगी फ़िल-रेट। amount घटाएँ और इसके बजाय कम अल्फा वाले बड़े पार्टिकल उपयोग करें।

11. Godot 3 से 4 में माइग्रेशन

यदि आप किसी प्रोजेक्ट को Godot 3 से Godot 4 में माइग्रेट कर रहे हैं, तो पार्टिकल के मुख्य बदलाव यहाँ दिए गए हैं: