Particle System

예제 :)

https://github.com/eazuooz/YamYamEngine/commit/ef9a0e889bd89a4b810d83edeabb85d20277f724

Particle refactoring · eazuooz/YamYamEngine@ef9a0e8

파티클이란?

물리학에서 입자는 본질적으로 기본 또는 기본 요소인 작고 국소화된 물체를 의미합니다. 이러한 물체는 물질 입자 또는 힘을 전달하는 입자일 수 있습니다. 물질 입자는 우주의 구성 요소이며 전자, 쿼크, 중성미자 등의 입자를 포함합니다. 힘 운반 입자는 물질 입자 간의 상호작용을 매개하며 전자기력, 약력, 강력, 중력 등 자연의 근본적인 힘을 담당합니다.

입자는 질량, 전하, 스핀과 같은 속성을 가질 수 있습니다. 질량은 입자에 포함된 물질의 양을 결정하고, 전하량은 전자기장과의 상호작용을 결정하며, 스핀은 각운동량과 관련된 본질적인 속성입니다.

입자는 매우 작은 규모의 현상을 다루는 물리학의 한 분야인 양자역학의 틀 안에서 설명됩니다. 양자역학은 입자가 상황에 따라 파동과 입자 같은 행동을 모두 나타낼 수 있다는 파동-입자 이중성 개념을 도입합니다.

입자 물리학에서 과학자들은 강력한 입자 가속기와 검출기를 사용하여 입자의 특성과 상호 작용을 연구하고 이해합니다. 이러한 실험을 통해 중력을 제외한 기본 입자와 그 상호작용을 설명하는 현재의 이론적 틀인 표준모형이 개발되었습니다.

 

게임에서는 이러한 시스템을 구현하여 다음과 같은 여러가지 효과들을 그래픽적으로 표현할수 있습니다.

 

그래서 우리는 Particle System 이라는 컴포넌트를 제작하고 해당 컴포넌트를 통해서 여러가지 파티클의 상태값을 조정할수 있도록 구현하였습니다.

namespace ya
{
	enum class eSimulationSpace
	{
		Local,
		World,
	};

	class ParticleSystem : public BaseRenderer
	{
	public:
		ParticleSystem();
		~ParticleSystem();

		virtual void Initialize() override;
		virtual void Update() override;
		virtual void LateUpdate() override;
		virtual void Render() override;

		void SetSimulationSpace(eSimulationSpace space) { mSimulationSpace = space; }

	private:
		class StructedBuffer* mBuffer;
		class StructedBuffer* mSharedBuffer;

		std::shared_ptr<ParticleShader> mCS;
		renderer::ParticleSystemCB mCBData;
		float	mTime;

		Vector4 mStartSize;
		Vector4 mStartColor;
		
		float   mStartLifeTime;
		float	mStartSpeed;
		float	mFrequency;
		UINT    mMaxParticles;
		
		eSimulationSpace mSimulationSpace;
		float	mRadius;
	};
}

해당 값들을 조정하여 속도, 주기, 크기 등등 여러가지 효과를 만들수 있습니다.

 

파티클 시스템에서 핵심은 파티클은 단순하게 여러개의 텍스처로 그려주면 되기 때문에

Rect(4개의 정점)이 아닌 Point(하나의 정점)을 vertex shader로 보내줍니다.

Point정점을 Geometry shader로 보내서 Rect메시로 만들어서 사용하면 점정셰이도 호출횟수를 줄여서

연산에서의 이점을 가져갈수 있습니다.

 

정점셰이더에서는 Local position만 geometry shader로 보내줍니다.

#include "globals.hlsli"

struct VSIn
{
    float3 LocalPosition : POSITION;
    uint Instance : SV_InstanceID;
};

struct VSOut
{
    float4 LocalPosition : SV_Position;
    uint Instance : SV_InstanceID;
};

VSOut main(VSIn In)
{
    VSOut Out = (VSOut) 0.f;
  
    Out.LocalPosition = float4(In.LocalPosition, 1.0f);
    Out.Instance = In.Instance;
        
    return Out;
}

그리고 Geometry shader에서 정점을 복사해준후 늘려줍니다.

#include "globals.hlsli"

struct VSOut
{
    float4 LocalPosition : SV_Position;
    uint Instance : SV_InstanceID;
};

struct GSOut
{
    float4 Position : SV_Position;
    float2 UV : TEXCOORD;
    uint Instance : SV_InstanceID;
};

StructuredBuffer<Particle> ParticleBufferGS : register(t16);

[maxvertexcount(6)]
void main(point VSOut In[1], inout TriangleStream<GSOut> output)
{
    GSOut Out[4] = { (GSOut) 0.f, (GSOut) 0.f, (GSOut) 0.f, (GSOut) 0.f };
    
    if (0 == ParticleBufferGS[In[0].Instance].active)
        return;
   
        
    float3 vWorldPos = In[0].LocalPosition.xyz + ParticleBufferGS[In[0].Instance].position.xyz;
    
    if (simulationSpace == 0)
    {
        vWorldPos += world._41_42_43;
    }
    
    float3 vViewPos = mul(float4(vWorldPos, 1.f), view).xyz;
    float3 vScale = startSize.xyz;
    
    float3 NewPos[4] =
    {
        vViewPos - float3(-0.5f, 0.5f, 0.f)     * vScale,
        vViewPos - float3(0.5f, 0.5f, 0.f)      * vScale,
        vViewPos - float3(0.5f, -0.5f, 0.f)     * vScale,
        vViewPos - float3(-0.5f, -0.5f, 0.f)    * vScale
    };
    
    for (int i = 0; i < 4; ++i)
    {
        Out[i].Position = mul(float4(NewPos[i], 1.f), projection);
    }
    
    
    Out[0].UV = float2(0.f, 0.f);
    Out[1].UV = float2(1.f, 0.f);
    Out[2].UV = float2(1.f, 1.f);
    Out[3].UV = float2(0.f, 1.f);
       
    Out[0].Instance = In[0].Instance;
    Out[1].Instance = In[0].Instance;
    Out[2].Instance = In[0].Instance;
    Out[3].Instance = In[0].Instance;
    // 0 -- 1
    // | \  |
    // 3 -- 2
    output.Append(Out[0]);
    output.Append(Out[1]);
    output.Append(Out[2]);
    output.RestartStrip();
    
    output.Append(Out[0]);
    output.Append(Out[2]);
    output.Append(Out[3]);
    output.RestartStrip();
}

픽셀셰이더에서는 그냥 출력해주시면 됩니다.

#include "globals.hlsli"


struct GSOut
{
    float4 Position : SV_Position;
    float2 UV : TEXCOORD;
    uint Instance : SV_InstanceID;
};

float4 main(GSOut In) : SV_Target
{
    float4 Color = (float4) 0.f;
        
    Color = triangleTexture.Sample(anisotropicSampler, In.UV);
    
    if (Color.a <= 0.f)
        discard;
    
    //float fRatio = ParticleBufferGS[In.Instance] / ParticleBuffer[_in.iInstance].fMaxTime;
    Color.rgb *= startColor.rgb;
    
    
    
    return Color;

}

 

마지막으로 수많은 particle이 각각 연산이 되어야 하기 때문에 파티클의 이동이나 활성화등 연산을 CPU에서 하는것보다 GPU에서 하는것이 효율적입니다.

Dx11에 Compute shader를 이용해 파티클을 계산해주면 그래픽카드를 이용하여 병렬적으로 처리가 가능합니다.

#include "globals.hlsli"


RWStructuredBuffer<Particle> ParticleBufferCS : register(u0);
RWStructuredBuffer<ParticleShared> ParticleSharedBufferCS : register(u1);


[numthreads(128, 1, 1)]
void main(uint3 _id : SV_DispatchThreadID)
{
    if (maxParticles <= _id.x)
        return;
        
    if (0 == ParticleBufferCS[_id.x].active)
    {
        while (0 < ParticleSharedBufferCS[0].gActiveCount)
        {
            int iOriginValue = ParticleSharedBufferCS[0].gActiveCount;
            int iExchange = iOriginValue - 1;
        
            //InterlockedExchange(ParticleSharedBufferCS[0].gActiveCount
            //, iExchange, iExchange);
            InterlockedCompareExchange(ParticleSharedBufferCS[0].gActiveCount
            , iOriginValue, iExchange, iExchange);
        
            if (iOriginValue == iExchange)
            {
                ParticleBufferCS[_id.x].active = 1;
                break;
            }
        }
        
        if (ParticleBufferCS[_id.x].active)
        {
            // 랜덤값으로 위치와 방향을 설정한다.
            // 샘플링을 시도할 UV 를 계산한다.
            float4 vRandom = (float4) 0.f;
            
            float2 vUV = float2((float) _id.x / maxParticles, 0.5f);
            vUV.x += elapsedTime;
            vUV.y += sin((vUV.x + elapsedTime) * 3.141592f * 2.f * 10.f) * 0.5f;
            
            vRandom = float4
            (
                  GaussianBlur(vUV + float2(0.f, 0.f)).x
                , GaussianBlur(vUV + float2(0.1f, 0.f)).x
                , GaussianBlur(vUV + float2(0.2f, 0.f)).x
                , GaussianBlur(vUV + float2(0.3f, 0.f)).x
            );
            
            //ParticleBufferCS[_id.x].position.xyz = vRandom.xyz * 1000.0f - 500.0f;
            //ParticleBufferCS[_id.x].position.z = 100.f;
            
                      // 사각형범위로 스폰
            // Particle.vRelativePos.xyz = vRandom.xyz * SpawnRange - SpawnRange / 2.f;
            
            // 원형 범위로 스폰
            float fTheta = vRandom.x * 3.141592f * 2.f;
            ParticleBufferCS[_id.x].position.xy = float2(cos(fTheta), sin(fTheta)) * vRandom.y * radius;
            ParticleBufferCS[_id.x].position.z = 0.f;
            ParticleBufferCS[_id.x].direction.xy 
                = -normalize(float2(ParticleBufferCS[_id.x].position.xy));
            
            if (simulationSpace)
            {
                ParticleBufferCS[_id.x].position.xyz += worldPosition.xyz;
            }
            
            // 파티클 속력
            ParticleBufferCS[_id.x].speed = startSpeed; /*vRandom.z * (maxSpeed - minSpeed) + minSpeed*/;
            
            // 파티클 Life
            ParticleBufferCS[_id.x].time = 0.f;
            ParticleBufferCS[_id.x].lifeTime = startLifeTime; //vRandom.w * (MaxLife - MinLife) + MinLife;
        }
    }
    else
    {
        ParticleBufferCS[_id.x].time += deltaTime;
        if (ParticleBufferCS[_id.x].lifeTime < ParticleBufferCS[_id.x].time)
        {
            ParticleBufferCS[_id.x].active = 0;
        }
        else
        {
            ParticleBufferCS[_id.x].position 
            += ParticleBufferCS[_id.x].direction * ParticleBufferCS[_id.x].speed * deltaTime;
        }
        //ParticleBufferCS[_id.x].position += ParticleBufferCS[_id.x].direction 
        //* ParticleBufferCS[_id.x].speed * deltaTime;
    }
}