Thinking Different




Tutorial 39 - 파티클 시스템



원문 : http://www.rastertek.com/dx11tut39.html



이 튜토리얼에서는 HLSL 및 C ++을 사용하여 DirectX 11에서 파티클 시스템을 만드는 방법에 대해 설명합니다.


파티클은 대개 쿼드에 배치 된 단일 텍스처를 사용하여 만들어집니다. 그리고 그 쿼드는 눈, 비, 연기, 불, 나뭇잎과 같은 것들을 모방하기 위해 몇 가지 기본 물리를 사용하여 각 프레임의 수백 배로 렌더링됩니다. 일반적으로 작지만 유사한 요소로 많이 구성됩니다. 이 튜토리얼에서는 단일 다이아몬드 텍스처를 사용하여 각 프레임의 수백 배를 렌더링하여 다채로운 다이아몬드 폭포 스타일 효과를 만듭니다. 또한 블렌드를 사용하여 파티클을 함께 블렌드하여 계층화 된 파티클이 누적되어 서로 색상을 추가합니다.



TimerClass를 사용하여 새 파티클을 방출할 시기를 결정합니다. 파티클을 음영 처리하는 데 사용되는 새로운 클래스를 ParticleShaderClass라고 합니다. 마지막으로 새로운 파티클 시스템 자체가 ParticleSystemClass에 캡슐화 됩니다.



프레임워크





Particlesystemclass.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#pragma once
 
 
class TextureClass;
 
class ParticleSystemClass
{
private:
    struct ParticleType
    {
        float positionX, positionY, positionZ;
        float red, green, blue;
        float velocity;
        bool active;
    };
 
    struct VertexType
    {
        XMFLOAT3 position;
        XMFLOAT2 texture;
        XMFLOAT4 color;
    };
 
public:
    ParticleSystemClass();
    ParticleSystemClass(const ParticleSystemClass&);
    ~ParticleSystemClass();
 
    bool Initialize(ID3D11Device*const WCHAR*);
    void Shutdown();
    bool Frame(float, ID3D11DeviceContext*);
    void Render(ID3D11DeviceContext*);
 
    ID3D11ShaderResourceView* GetTexture();
    int GetIndexCount();
 
private:
    bool LoadTexture(ID3D11Device*const WCHAR*);
    void ReleaseTexture();
 
    bool InitializeParticleSystem();
    void ShutdownParticleSystem();
 
    bool InitializeBuffers(ID3D11Device*);
    void ShutdownBuffers();
 
    void EmitParticles(float);
    void UpdateParticles(float);
    void KillParticles();
 
    bool UpdateBuffers(ID3D11DeviceContext*);
    void RenderBuffers(ID3D11DeviceContext*);
 
private:
    float m_particleDeviationX = 0;
    float m_particleDeviationY = 0;
    float m_particleDeviationZ = 0;
    float m_particleVelocity = 0;
    float m_particleVelocityVariation = 0;
    float m_particleSize = 0;
    float m_particlesPerSecond = 0;
    int m_maxParticles = 0;
 
    int m_currentParticleCount = 0;
    float m_accumulatedTime = 0;
 
    TextureClass* m_Texture = nullptr;
    ParticleType* m_particleList = nullptr;
    int m_vertexCount = 0;
    int m_indexCount = 0;
    VertexType* m_vertices = nullptr;
    ID3D11Buffer* m_vertexBuffer = nullptr;
    ID3D11Buffer* m_indexBuffer = nullptr;
};
cs



Particlesystemclass.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
#include "stdafx.h"
#include "TextureClass.h"
#include "particlesystemclass.h"
 
 
ParticleSystemClass::ParticleSystemClass()
{
}
 
 
ParticleSystemClass::ParticleSystemClass(const ParticleSystemClass& other)
{
}
 
 
ParticleSystemClass::~ParticleSystemClass()
{
}
 
 
bool ParticleSystemClass::Initialize(ID3D11Device* device, const WCHAR* textureFilename)
{
    // 파티클에 사용되는 텍스처를 로드합니다.
    if(!LoadTexture(device, textureFilename))
    {
        return false;
    }
 
    // 파티클 시스템을 초기화합니다.
    if(!InitializeParticleSystem())
    {
        return false;
    }
 
    // 파티클을 렌더링하는 데 사용할 버퍼를 만듭니다.
    if(!InitializeBuffers(device))
    {
        return false;
    }
 
    return true;
}
 
 
void ParticleSystemClass::Shutdown()
{
    // 버퍼를 해제합니다.
    ShutdownBuffers();
 
    // 파티클 시스템을 해제합니다.
    ShutdownParticleSystem();
 
    // 파티클에 사용된 텍스처를 해제합니다.
    ReleaseTexture();
}
 
 
bool ParticleSystemClass::Frame(float frameTime, ID3D11DeviceContext* deviceContext)
{
    // 오래된 파티클을 해제합니다.
    KillParticles();
 
    // 새 파티클을 방출합니다.
    EmitParticles(frameTime);
    
    // 파티클 위치를 업데이트 합니다.
    UpdateParticles(frameTime);
 
    // 동적 정점 버퍼를 각 파티클의 새 위치로 업데이트합니다.
    return UpdateBuffers(deviceContext);
}
 
 
void ParticleSystemClass::Render(ID3D11DeviceContext* deviceContext)
{
    // 리기를 준비하기 위해 그래픽 파이프 라인에 꼭지점과 인덱스 버퍼를 놓습니다.
    RenderBuffers(deviceContext);
}
 
 
ID3D11ShaderResourceView* ParticleSystemClass::GetTexture()
{
    return m_Texture->GetTexture();
}
 
 
int ParticleSystemClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
bool ParticleSystemClass::LoadTexture(ID3D11Device* device, const WCHAR* filename)
{
    // 텍스처 오브젝트를 생성한다.
    m_Texture = new TextureClass;
    if(!m_Texture)
    {
        return false;
    }
 
    // 텍스처 오브젝트를 초기화한다.
    return m_Texture->Initialize(device, filename);
}
 
 
void ParticleSystemClass::ReleaseTexture()
{
    // 텍스처 오브젝트를 릴리즈한다.
    if(m_Texture)
    {
        m_Texture->Shutdown();
        delete m_Texture;
        m_Texture = 0;
    }
}
 
 
bool ParticleSystemClass::InitializeParticleSystem()
{
    // 방출 될 때 파티클이 위치 할 수 있는 임의의 편차를 설정합니다.
    m_particleDeviationX = 0.5f;
    m_particleDeviationY = 0.1f;
    m_particleDeviationZ = 2.0f;
 
    // 파티클의 속도와 속도 변화를 설정합니다.
    m_particleVelocity = 1.0f;
    m_particleVelocityVariation = 0.2f;
 
    // 파티클의 물리적 크기를 설정합니다.
    m_particleSize = 0.2f;
 
    // 초당 방출 할 파티클 수를 설정합니다.
    m_particlesPerSecond = 250.0f;
 
    // 파티클 시스템에 허용되는 최대 파티클 수를 설정합니다.
    m_maxParticles = 5000;
 
    // 파티클 리스트를 생성합니다.
    m_particleList = new ParticleType[m_maxParticles];
    if(!m_particleList)
    {
        return false;
    }
 
    // 파티클 리스트를 초기화 합니다.
    for(int i=0; i<m_maxParticles; i++)
    {
        m_particleList[i].active = false;
    }
 
    // 아직 배출되지 않으므로 현재 파티클 수를 0으로 초기화합니다.
    m_currentParticleCount = 0;
 
    // 초당 파티클 방출 속도의 초기 누적 시간을 지웁니다.
    m_accumulatedTime = 0.0f;
 
    return true;
}
 
 
void ParticleSystemClass::ShutdownParticleSystem()
{
    // 파티클 목록을 해제합니다.
    if(m_particleList)
    {
        delete [] m_particleList;
        m_particleList = 0;
    }
}
 
 
bool ParticleSystemClass::InitializeBuffers(ID3D11Device* device)
{
    // 정점 배열의 최대 정점 수를 설정합니다.
    m_vertexCount = m_maxParticles * 6;
 
    // 인덱스 배열의 최대 인덱스 수를 설정합니다.
    m_indexCount = m_vertexCount;
 
    // 렌더링 될 입자에 대한 정점 배열을 만듭니다.
    m_vertices = new VertexType[m_vertexCount];
    if(!m_vertices)
    {
        return false;
    }
 
    // 인덱스 배열을 만듭니다.
    unsigned long* indices = new unsigned long[m_indexCount];
    if(!indices)
    {
        return false;
    }
 
    // 처음에는 정점 배열을 0으로 초기화합니다.
    memset(m_vertices, 0, (sizeof(VertexType) * m_vertexCount));
 
    // 인덱스 배열을 초기화합니다.
    for(int i=0; i<m_indexCount; i++)
    {
        indices[i] = i;
    }
 
    // 동적 정점 버퍼의 설명을 설정한다.
    D3D11_BUFFER_DESC vertexBufferDesc;
    vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    vertexBufferDesc.MiscFlags = 0;
    vertexBufferDesc.StructureByteStride = 0;
 
    // subresource 구조에 정점 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA vertexData;
    vertexData.pSysMem = m_vertices;
    vertexData.SysMemPitch = 0;
    vertexData.SysMemSlicePitch = 0;
 
    // 이제 마침내 정점 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer)))
    {
        return false;
    }
 
    // 정적 인덱스 버퍼의 설명을 설정합니다.
    D3D11_BUFFER_DESC indexBufferDesc;
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long* m_indexCount;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    indexBufferDesc.StructureByteStride = 0;
 
    // 하위 리소스 구조에 인덱스 데이터에 대한 포인터를 제공합니다.
    D3D11_SUBRESOURCE_DATA indexData;
    indexData.pSysMem = indices;
    indexData.SysMemPitch = 0;
    indexData.SysMemSlicePitch = 0;
 
    // 인덱스 버퍼를 만듭니다.
    if(FAILED(device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer)))
    {
        return false;
    }
 
    // 더 이상 필요하지 않으므로 인덱스 배열을 해제합니다.
    delete [] indices;
    indices = 0;
 
    return true;
}
 
 
void ParticleSystemClass::ShutdownBuffers()
{
    // 인덱스 버퍼를 해제합니다.
    if(m_indexBuffer)
    {
        m_indexBuffer->Release();
        m_indexBuffer = 0;
    }
 
    // 버텍스 버퍼를 해제한다.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
}
 
 
void ParticleSystemClass::EmitParticles(float frameTime)
{
    // 프레임 시간을 증가시킵니다.
    m_accumulatedTime += frameTime;
 
    // 이제 파티클 출력을 false로 설정합니다.
    bool emitParticle = false;
    
    // 새 파티클을 방출할 시간인지 확인합니다.
    if(m_accumulatedTime > (1000.0f / m_particlesPerSecond))
    {
        m_accumulatedTime = 0.0f;
        emitParticle = true;
    }
 
    // 방출 할 파티클이 있으면 프레임 당 하나씩 방출합니다.
    if((emitParticle == true&& (m_currentParticleCount < (m_maxParticles - 1)))
    {
        m_currentParticleCount++;
 
        // 이제 임의 화 된 파티클 속성을 생성합니다.
        float positionX = (((float)rand()-(float)rand())/RAND_MAX) * m_particleDeviationX;
        float positionY = (((float)rand()-(float)rand())/RAND_MAX) * m_particleDeviationY;
        float positionZ = (((float)rand()-(float)rand())/RAND_MAX) * m_particleDeviationZ;
 
        float velocity = m_particleVelocity + (((float)rand()-(float)rand())/RAND_MAX) * m_particleVelocityVariation;
 
        float red   = (((float)rand()-(float)rand())/RAND_MAX) + 0.5f;
        float green = (((float)rand()-(float)rand())/RAND_MAX) + 0.5f;
        float blue  = (((float)rand()-(float)rand())/RAND_MAX) + 0.5f;
 
        // 이제 블렌딩을 위해 파티클을 뒤에서 앞으로 렌더링해야하므로 파티클 배열을 정렬해야 합니다.
        // Z 깊이를 사용하여 정렬하므로 목록에서 파티클을 삽입해야 하는 위치를 찾아야합니다.
        int index = 0;
        bool found = false;
        while(!found)
        {
            if((m_particleList[index].active == false|| (m_particleList[index].positionZ < positionZ))
            {
                found = true;
            }
            else
            {
                index++;
            }
        }
 
        // 삽입 할 위치를 알았으므로 인덱스에서 한 위치 씩 배열을 복사하여 새 파티클을 위한 공간을 만들어야합니다.
        int i = m_currentParticleCount;
        int j = i - 1;
 
        while(i != index)
        {
            m_particleList[i].positionX = m_particleList[j].positionX;
            m_particleList[i].positionY = m_particleList[j].positionY;
            m_particleList[i].positionZ = m_particleList[j].positionZ;
            m_particleList[i].red       = m_particleList[j].red;
            m_particleList[i].green     = m_particleList[j].green;
            m_particleList[i].blue      = m_particleList[j].blue;
            m_particleList[i].velocity  = m_particleList[j].velocity;
            m_particleList[i].active    = m_particleList[j].active;
            i--;
            j--;
        }
 
        // 이제 정확한 깊이 순서로 파티클 배열에 삽입하십시오.
        m_particleList[index].positionX = positionX;
        m_particleList[index].positionY = positionY;
        m_particleList[index].positionZ = positionZ;
        m_particleList[index].red       = red;
        m_particleList[index].green     = green;
        m_particleList[index].blue      = blue;
        m_particleList[index].velocity  = velocity;
        m_particleList[index].active    = true;
    }
}
 
 
void ParticleSystemClass::UpdateParticles(float frameTime)
{
    // 각 프레임은 위치, 속도 및 프레임 시간을 사용하여 아래쪽으로 이동하여 모든 파티클을 업데이트합니다.
    for(int i=0; i<m_currentParticleCount; i++)
    {
        m_particleList[i].positionY = m_particleList[i].positionY - (m_particleList[i].velocity * frameTime * 0.001f);
    }
}
 
 
void ParticleSystemClass::KillParticles()
{
    // 특정 높이 범위를 벗어난 모든 파티클을 제거합니다.
    for(int i=0; i<m_maxParticles; i++)
    {
        if((m_particleList[i].active == true&& (m_particleList[i].positionY < -3.0f))
        {
            m_particleList[i].active = false;
            m_currentParticleCount--;
 
            // 이제 모든 살아있는 파티클을 배열위로 이동시켜 파괴된 파티클을 지우고 배열을 올바르게 정렬된 상태로 유지합니다.
            for(int j=i; j<m_maxParticles-1; j++)
            {
                m_particleList[j].positionX = m_particleList[j+1].positionX;
                m_particleList[j].positionY = m_particleList[j+1].positionY;
                m_particleList[j].positionZ = m_particleList[j+1].positionZ;
                m_particleList[j].red       = m_particleList[j+1].red;
                m_particleList[j].green     = m_particleList[j+1].green;
                m_particleList[j].blue      = m_particleList[j+1].blue;
                m_particleList[j].velocity  = m_particleList[j+1].velocity;
                m_particleList[j].active    = m_particleList[j+1].active;
            }
        }
    }
}
 
 
bool ParticleSystemClass::UpdateBuffers(ID3D11DeviceContext* deviceContext)
{
    // 처음에는 정점 배열을 0으로 초기화합니다.
    VertexType* verticesPtr;
    memset(m_vertices, 0, (sizeof(VertexType) * m_vertexCount));
 
    // 이제 파티클 목록 배열에서 정점 배열을 만듭니다. 각 파티클은 두 개의 삼각형으로 만들어진 쿼드입니다.
    int index = 0;
 
    for(int i=0; i<m_currentParticleCount; i++)
    {
        // 왼쪽 아래.
        m_vertices[index].position = XMFLOAT3(m_particleList[i].positionX - m_particleSize,
 m_particleList[i].positionY - m_particleSize, m_particleList[i].positionZ);
        m_vertices[index].texture = XMFLOAT2(0.0f, 1.0f);
        m_vertices[index].color = XMFLOAT4(m_particleList[i].red, m_particleList[i].green, m_particleList[i].blue, 1.0f);
        index++;
 
        // 왼쪽 위.
        m_vertices[index].position = XMFLOAT3(m_particleList[i].positionX - m_particleSize,
 m_particleList[i].positionY + m_particleSize, m_particleList[i].positionZ);
        m_vertices[index].texture = XMFLOAT2(0.0f, 0.0f);
        m_vertices[index].color = XMFLOAT4(m_particleList[i].red, m_particleList[i].green, m_particleList[i].blue, 1.0f);
        index++;
 
        // 오른쪽 아래.
        m_vertices[index].position = XMFLOAT3(m_particleList[i].positionX + m_particleSize,
 m_particleList[i].positionY - m_particleSize, m_particleList[i].positionZ);
        m_vertices[index].texture = XMFLOAT2(1.0f, 1.0f);
        m_vertices[index].color = XMFLOAT4(m_particleList[i].red, m_particleList[i].green, m_particleList[i].blue, 1.0f);
        index++;
 
        // 오른쪽 아래.
        m_vertices[index].position = XMFLOAT3(m_particleList[i].positionX + m_particleSize,
 m_particleList[i].positionY - m_particleSize, m_particleList[i].positionZ);
        m_vertices[index].texture = XMFLOAT2(1.0f, 1.0f);
        m_vertices[index].color = XMFLOAT4(m_particleList[i].red, m_particleList[i].green, m_particleList[i].blue, 1.0f);
        index++;
 
        // 왼쪽 위.
        m_vertices[index].position = XMFLOAT3(m_particleList[i].positionX - m_particleSize,
 m_particleList[i].positionY + m_particleSize, m_particleList[i].positionZ);
        m_vertices[index].texture = XMFLOAT2(0.0f, 0.0f);
        m_vertices[index].color = XMFLOAT4(m_particleList[i].red, m_particleList[i].green, m_particleList[i].blue, 1.0f);
        index++;
 
        // 오른쪽 위.
        m_vertices[index].position = XMFLOAT3(m_particleList[i].positionX + m_particleSize, 
m_particleList[i].positionY + m_particleSize, m_particleList[i].positionZ);
        m_vertices[index].texture = XMFLOAT2(1.0f, 0.0f);
        m_vertices[index].color = XMFLOAT4(m_particleList[i].red, m_particleList[i].green, m_particleList[i].blue, 1.0f);
        index++;
    }
    
    // 정점 버퍼를 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if(FAILED(deviceContext->Map(m_vertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0&mappedResource)))
    {
        return false;
    }
 
    // 정점 버퍼의 데이터를 가리키는 포인터를 얻는다.
    verticesPtr = (VertexType*)mappedResource.pData;
 
    // 데이터를 정점 버퍼에 복사합니다.
    memcpy(verticesPtr, (void*)m_vertices, (sizeof(VertexType) * m_vertexCount));
 
    // 정점 버퍼의 잠금을 해제합니다.
    deviceContext->Unmap(m_vertexBuffer, 0);
 
    return true;
}
 
 
void ParticleSystemClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
{
    // 정점 버퍼 보폭 및 오프셋을 설정합니다.
    unsigned int stride = sizeof(VertexType); 
    unsigned int offset = 0;
    
    // 렌더링 할 수 있도록 입력 어셈블러에서 정점 버퍼를 활성으로 설정합니다.
    deviceContext->IASetVertexBuffers(01&m_vertexBuffer, &stride, &offset);
 
    // 렌더링 할 수 있도록 입력 어셈블러에서 인덱스 버퍼를 활성으로 설정합니다.
    deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
 
    // 이 정점 버퍼에서 렌더링 되어야 하는 프리미티브 유형을 설정합니다.
    deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}
cs




particle_vs.hlsl 및 particle_ps.hlsl 은 파티클을 렌더링하는 데 사용되는 기본적인 텍스쳐 쉐이더 입니다.


particle_vs.hlsl


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
////////////////////////////////////////////////////////////////////////////////
// Filename: particle_vs.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};
 
 
//////////////
// TYPEDEFS //
//////////////
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
    float4 color : COLOR;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float4 color : COLOR;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType ParticleVertexShader(VertexInputType input)
{
    PixelInputType output;
    
 
    // 적절한 행렬 계산을 위해 위치 벡터를 4 단위로 변경합니다.
    input.position.w = 1.0f;
 
    // 월드, 뷰 및 투영 행렬에 대한 정점의 위치를 ​​계산합니다.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // 픽셀 쉐이더의 텍스처 좌표를 저장한다.
    output.tex = input.tex;
    
    // 픽셀 쉐이더의 입자 색상을 저장합니다. 
    output.color = input.color;
 
    return output;
}
cs



particle_ps.hlsl


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
////////////////////////////////////////////////////////////////////////////////
// Filename: particle_ps.hlsl
////////////////////////////////////////////////////////////////////////////////
 
 
/////////////
// GLOBALS //
/////////////
Texture2D shaderTexture;
SamplerState SampleType;
 
 
//////////////
// TYPEDEFS //
//////////////
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float4 color : COLOR;
};
 
 
////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 ParticlePixelShader(PixelInputType input) : SV_TARGET
{
    float4 textureColor;
    float4 finalColor;
 
 
    // 이 텍스처 좌표 위치에서 샘플러를 사용하여 텍스처에서 픽셀 색상을 샘플링합니다.
    textureColor = shaderTexture.Sample(SampleType, input.tex);
 
    // 텍스처 색상과 입자 색상을 결합하여 최종 색상 결과를 얻습니다.
    finalColor = textureColor * input.color;
 
    return finalColor;
}
cs




ParticleShaderClass는 TextureShaderClass가 파티클의 색상 구성 요소를 처리하도록 수정 된 것입니다.


Particleshaderclass.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#pragma once
 
class ParticleShaderClass : public AlignedAllocationPolicy<16>
{
private:
    struct MatrixBufferType
    {
        XMMATRIX world;
        XMMATRIX view;
        XMMATRIX projection;
    };
 
public:
    ParticleShaderClass();
    ParticleShaderClass(const ParticleShaderClass&);
    ~ParticleShaderClass();
 
    bool Initialize(ID3D11Device*, HWND);
    void Shutdown();
    bool Render(ID3D11DeviceContext*int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*);
 
private:
    bool InitializeShader(ID3D11Device*, HWND, const WCHAR*const WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, const WCHAR*);
 
    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*);
    void RenderShader(ID3D11DeviceContext*int);
 
private:
    ID3D11VertexShader* m_vertexShader = nullptr;
    ID3D11PixelShader* m_pixelShader = nullptr;
    ID3D11InputLayout* m_layout = nullptr;
    ID3D11Buffer* m_matrixBuffer = nullptr;
    ID3D11SamplerState* m_sampleState = nullptr;
};
cs



Particleshaderclass.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
#include "stdafx.h"
#include "ParticleShaderClass.h"
 
 
ParticleShaderClass::ParticleShaderClass()
{
}
 
 
ParticleShaderClass::ParticleShaderClass(const ParticleShaderClass& other)
{
}
 
 
ParticleShaderClass::~ParticleShaderClass()
{
}
 
 
bool ParticleShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
    // 정점 및 픽셀 쉐이더를 초기화합니다.
    return InitializeShader(device, hwnd, L"../Dx11Demo_39/particle_vs.hlsl", L"../Dx11Demo_39/particle_ps.hlsl");
}
 
 
void ParticleShaderClass::Shutdown()
{
    // 버텍스 및 픽셀 쉐이더와 관련된 객체를 종료합니다.
    ShutdownShader();
}
 
 
bool ParticleShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                                XMMATRIX projectionMatrix, ID3D11ShaderResourceView* texture)
{
    // 렌더링에 사용할 셰이더 매개 변수를 설정합니다.
    if(!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture))
    {
        return false;
    }
 
    // 설정된 버퍼를 셰이더로 렌더링한다.
    RenderShader(deviceContext, indexCount);
 
    return true;
}
 
 
bool ParticleShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, const WCHAR* psFilename)
{
    ID3D10Blob* errorMessage = nullptr;
 
    // 버텍스 쉐이더 코드를 컴파일한다.
    ID3D10Blob* vertexShaderBuffer = nullptr;
    if(FAILED(D3DCompileFromFile(vsFilename, NULLNULL"ParticleVertexShader""vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
 &vertexShaderBuffer, &errorMessage)))
    {
        // 셰이더 컴파일 실패시 오류메시지를 출력합니다.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
        }
        // 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
        else
        {
            MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }
    
    // 픽셀 쉐이더 코드를 컴파일한다.
    ID3D10Blob* pixelShaderBuffer = nullptr;
    if(FAILED(D3DCompileFromFile(psFilename, NULLNULL"ParticlePixelShader""ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
 &pixelShaderBuffer, &errorMessage)))
    {
        // 셰이더 컴파일 실패시 오류메시지를 출력합니다.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
        }
        // 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
        else
        {
            MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }
 
    // 버퍼로부터 정점 셰이더를 생성한다.
    if(FAILED(device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL,
 &m_vertexShader)))
    {
        return false;
    }
    
 
    // 버퍼에서 픽셀 쉐이더를 생성합니다.
    if(FAILED(device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL
&m_pixelShader)))
    {
        return false;
    }
 
    // 정점 입력 레이아웃 구조체를 설정합니다.
    // 이 설정은 ModelClass와 셰이더의 VertexType 구조와 일치해야합니다.
    D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
    polygonLayout[0].SemanticName = "POSITION";
    polygonLayout[0].SemanticIndex = 0;
    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[0].InputSlot = 0;
    polygonLayout[0].AlignedByteOffset = 0;
    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[0].InstanceDataStepRate = 0;
 
    polygonLayout[1].SemanticName = "TEXCOORD";
    polygonLayout[1].SemanticIndex = 0;
    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[1].InputSlot = 0;
    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[1].InstanceDataStepRate = 0;
 
    polygonLayout[2].SemanticName = "COLOR";
    polygonLayout[2].SemanticIndex = 0;
    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    polygonLayout[2].InputSlot = 0;
    polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[2].InstanceDataStepRate = 0;
 
    // 레이아웃의 요소 수를 가져옵니다.
    unsigned int numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
 
    // 정점 입력 레이아웃을 만듭니다.
    if(FAILED(device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
 vertexShaderBuffer->GetBufferSize(), &m_layout)))
    {
        return false;
    }
 
    // 더 이상 사용되지 않는 정점 셰이더 퍼버와 픽셀 셰이더 버퍼를 해제합니다.
    vertexShaderBuffer->Release();
    vertexShaderBuffer = 0;
 
    pixelShaderBuffer->Release();
    pixelShaderBuffer = 0;
 
    // 정점 셰이더에 있는 행렬 상수 버퍼의 구조체를 작성합니다.
    D3D11_BUFFER_DESC matrixBufferDesc;
    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
    matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    matrixBufferDesc.MiscFlags = 0;
    matrixBufferDesc.StructureByteStride = 0;
 
    // 상수 버퍼 포인터를 만들어 이 클래스에서 정점 셰이더 상수 버퍼에 접근할 수 있게 합니다.
    if(FAILED(device->CreateBuffer(&matrixBufferDesc, NULL&m_matrixBuffer)))
    {
        return false;
    }
 
    // 텍스처 샘플러 상태 설명을 만듭니다.
    D3D11_SAMPLER_DESC samplerDesc;
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samplerDesc.BorderColor[0= 0;
    samplerDesc.BorderColor[1= 0;
    samplerDesc.BorderColor[2= 0;
    samplerDesc.BorderColor[3= 0;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
 
    // 텍스처 샘플러 상태를 만듭니다.
    if(FAILED(device->CreateSamplerState(&samplerDesc, &m_sampleState)))
    {
        return false;
    }
 
    return true;
}
 
 
void ParticleShaderClass::ShutdownShader()
{
    // 샘플러 상태를 해제한다.
    if(m_sampleState)
    {
        m_sampleState->Release();
        m_sampleState = 0;
    }
 
    // 행렬 상수 버퍼를 해제합니다.
    if(m_matrixBuffer)
    {
        m_matrixBuffer->Release();
        m_matrixBuffer = 0;
    }
 
    // 레이아웃을 해제합니다.
    if(m_layout)
    {
        m_layout->Release();
        m_layout = 0;
    }
 
    // 픽셀 쉐이더를 해제합니다.
    if(m_pixelShader)
    {
        m_pixelShader->Release();
        m_pixelShader = 0;
    }
 
    // 버텍스 쉐이더를 놓습니다.
    if(m_vertexShader)
    {
        m_vertexShader->Release();
        m_vertexShader = 0;
    }
}
 
 
void ParticleShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, const WCHAR* shaderFilename)
{
    // 에러 메시지를 출력창에 표시합니다.
    OutputDebugStringA(reinterpret_cast<const char*>(errorMessage->GetBufferPointer()));
 
    // 에러 메세지를 반환합니다.
    errorMessage->Release();
    errorMessage = 0;
 
    // 컴파일 에러가 있음을 팝업 메세지로 알려줍니다.
    MessageBox(hwnd, L"Error compiling shader.", shaderFilename, MB_OK);
}
 
 
bool ParticleShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, 
                                             XMMATRIX projectionMatrix, ID3D11ShaderResourceView* texture)
{
    // 행렬을 transpose하여 셰이더에서 사용할 수 있게 합니다
    worldMatrix = XMMatrixTranspose(worldMatrix);
    viewMatrix = XMMatrixTranspose(viewMatrix);
    projectionMatrix = XMMatrixTranspose(projectionMatrix);
 
    // 상수 버퍼의 내용을 쓸 수 있도록 잠급니다.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    if(FAILED(deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0&mappedResource)))
    {
        return false;
    }
 
    // 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
    MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
 
    // 상수 버퍼에 행렬을 복사합니다.
    dataPtr->world = worldMatrix;
    dataPtr->view = viewMatrix;
    dataPtr->projection = projectionMatrix;
 
    // 상수 버퍼의 잠금을 풉니다.
    deviceContext->Unmap(m_matrixBuffer, 0);
 
    // 정점 셰이더에서의 상수 버퍼의 위치를 설정합니다.
    unsigned bufferNumber = 0;
 
    // 이제 업데이트 된 값으로 버텍스 쉐이더에서 상수 버퍼를 설정합니다.
    deviceContext->VSSetConstantBuffers(bufferNumber, 1&m_matrixBuffer);
 
    // 픽셀 셰이더에서 셰이더 텍스처 리소스를 설정합니다.
    deviceContext->PSSetShaderResources(01&texture);
 
    return true;
}
 
 
void ParticleShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount)
{
    // 정점 입력 레이아웃을 설정합니다.
    deviceContext->IASetInputLayout(m_layout);
 
    // 삼각형을 그릴 정점 셰이더와 픽셀 셰이더를 설정합니다.
    deviceContext->VSSetShader(m_vertexShader, NULL0);
    deviceContext->PSSetShader(m_pixelShader, NULL0);
 
    // 픽셀 쉐이더에서 샘플러 상태를 설정합니다.
    deviceContext->PSSetSamplers(01&m_sampleState);
 
    // 삼각형을 렌더링합니다.
    deviceContext->DrawIndexed(indexCount, 00);
}
cs



D3DClass에서는 Initialize 함수를 변경해야했습니다. 알파 블렌딩 방정식을 수정해야합니다.


D3dclass.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth,
 float screenNear)
{
    // .....................
 
    // 알파 지원 블렌드 상태 설명을 만듭니다.
    blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
    blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
    blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;
    blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
    blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
    blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    blendStateDescription.RenderTarget[0].RenderTargetWriteMask = 0x0f;
 
    // .....................
}
cs



Graphicsclass.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#pragma once
 
/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;
 
 
class D3DClass;
class CameraClass;
class ParticleShaderClass;
class ParticleSystemClass;
 
class GraphicsClass
{
public:
    GraphicsClass();
    GraphicsClass(const GraphicsClass&);
    ~GraphicsClass();
 
    bool Initialize(intint, HWND);
    void Shutdown();
    bool Frame(float);
 
private:
    bool Render();
 
private:
    D3DClass* m_Direct3D = nullptr;
    CameraClass* m_Camera = nullptr;
    ParticleShaderClass* m_ParticleShader = nullptr;
    ParticleSystemClass* m_ParticleSystem = nullptr;
};
cs



Graphicsclass.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include "stdafx.h"
#include "d3dclass.h"
#include "cameraclass.h"
#include "particleshaderclass.h"
#include "particlesystemclass.h"
#include "graphicsclass.h"
 
 
GraphicsClass::GraphicsClass()
{
}
 
 
GraphicsClass::GraphicsClass(const GraphicsClass& other)
{
}
 
 
GraphicsClass::~GraphicsClass()
{
}
 
 
bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
    // Direct3D 객체 생성
    m_Direct3D = new D3DClass;
    if(!m_Direct3D)
    {
        return false;
    }
 
    // Direct3D 객체 초기화
    if(!m_Direct3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR))
    {
        MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK);
        return false;
    }
 
    // m_Camera 객체 생성
    m_Camera = new CameraClass;
    if (!m_Camera)
    {
        return false;
    }
 
    // 카메라 포지션 설정
    m_Camera->SetPosition(0.0f, -1.5f, -7.0f);
    
    // 파티클 셰이더 개체를 만듭니다.
    m_ParticleShader = new ParticleShaderClass;
    if(!m_ParticleShader)
    {
        return false;
    }
 
    // 파티클 셰이더 개체를 초기화합니다.
    if(!m_ParticleShader->Initialize(m_Direct3D->GetDevice(), hwnd))
    {
        MessageBox(hwnd, L"Could not initialize the particle shader object.", L"Error", MB_OK);
        return false;
    }
 
    // 파티클 시스템 객체를 만듭니다.
    m_ParticleSystem = new ParticleSystemClass;
    if(!m_ParticleSystem)
    {
        return false;
    }
 
    // 파티클 시스템 객체를 초기화합니다.
    if(!m_ParticleSystem->Initialize(m_Direct3D->GetDevice(), L"../Dx11Demo_39/data/star.dds"))
    {
        return false;
    }
 
    return true;
}
 
 
void GraphicsClass::Shutdown()
{
    // 파티클 시스템 객체를 해제합니다.
    if(m_ParticleSystem)
    {
        m_ParticleSystem->Shutdown();
        delete m_ParticleSystem;
        m_ParticleSystem = 0;
    }
 
    // particle shader 객체를 해제한다.
    if(m_ParticleShader)
    {
        m_ParticleShader->Shutdown();
        delete m_ParticleShader;
        m_ParticleShader = 0;
    }
 
    // m_Camera 객체 반환
    if (m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
 
    // Direct3D 객체 반환
    if(m_Direct3D)
    {
        m_Direct3D->Shutdown();
        delete m_Direct3D;
        m_Direct3D = 0;
    }
}
 
 
bool GraphicsClass::Frame(float frameTime)
{
    // 파티클 시스템에 대한 프레임 처리를 실행합니다.
    m_ParticleSystem->Frame(frameTime, m_Direct3D->GetDeviceContext());
 
    // 그래픽 랜더링 처리
    return Render();
}
 
 
bool GraphicsClass::Render()
{
    // 씬을 그리기 위해 버퍼를 지웁니다
    m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
 
    // 카메라의 위치에 따라 뷰 행렬을 생성합니다
    m_Camera->Render();
 
    // 카메라 및 d3d 객체에서 월드, 뷰 및 투영 행렬을 가져옵니다
    XMMATRIX worldMatrix, viewMatrix, projectionMatrix;
    m_Direct3D->GetWorldMatrix(worldMatrix);
    m_Camera->GetViewMatrix(viewMatrix);
    m_Direct3D->GetProjectionMatrix(projectionMatrix);
 
    // 알파 블렌딩을 켭니다.
    m_Direct3D->EnableAlphaBlending();
 
    // 파티클 시스템 버텍스와 인덱스 버퍼를 그래픽 파이프 라인에 배치하여 그리기를 준비합니다.
    m_ParticleSystem->Render(m_Direct3D->GetDeviceContext());
 
    // 텍스처 셰이더를 사용하여 모델을 렌더링합니다.
    if(!m_ParticleShader->Render(m_Direct3D->GetDeviceContext(), m_ParticleSystem->GetIndexCount(), worldMatrix, viewMatrix,
 projectionMatrix, m_ParticleSystem->GetTexture()))
    {
        return false;
    }
 
    // 알파 블렌딩을 끕니다.
    m_Direct3D->DisableAlphaBlending();
 
    // 렌더링 된 장면을 화면에 표시합니다.
    m_Direct3D->EndScene();
 
    return true;
}
cs



출력 화면




마치면서


이제는 매우 기본적인 파티클 시스템을 사용하여 이동 변수를 기반으로 파티클을 렌더링 할 수 있습니다. 그러나 유용한 파티클 시스템은 제시된 것보다 더 견고해야합니다.


파티클 시스템을 확장하기 위해 수행해야 할 첫 번째 작업은 완전히 데이터 기반이어야 한다는 것입니다. 파티클 시스템을 정의하는 모든 변수를 텍스트 파일에서 읽어 들이기 시작하면 변경 사항을 보기 위해 매번 다시 컴파일 할 필요가 없습니다. 결국 원하는 최종 결과는 파티클 시스템 속성을 실시간으로 동적으로 변경하는 일종의 슬라이더 바 시스템이어야합니다.


두 번째 변화는 인스턴스를 활용해야 한다는 것입니다. 이 다이렉트 X 11 기능은 각 프레임마다 약간의 위치 / 색상 변경으로 정확히 동일한 지오메트리를 가진 이와 같은 시스템을 위해 특별히 제작되었습니다.


세 번째 변경 사항은 파티클이 광고 게시판에 있어야하고 Z 깊이가 아니라 카메라에서 파티클의 거리를 기준으로 정렬하는 것입니다. 3D 시스템에서 움직이면 파티클은 카메라를 다시 마주 보도록 Y 축을 중심으로 회전해야합니다.


네 번째 변경 사항은 입자 배열을 보다 효율적으로 정렬해야 한다는 것입니다. 사용할 수 있는 여러 종류의 정렬 메커니즘이 있으며, 각각을 테스트 하여 최상의 속도 결과를 제공하는 것이 무엇인지 확인할 수 있습니다. 링크 된 목록과 같은 것을 사용하는 대신이 튜토리얼에서 배열 복사본을 사용했다는 것을 기억하십시오. 이것은 메모리 단편화를 방지하기 위해 수행되었습니다. 그러나 파티클을 위한 메모리 풀을 직접 설계하여 구성한다면 보다 효과적인 처리를 할 수 있습니다.


조사 할 가치가 있는 추가 변경 사항은 gpu의 입자에 대해 물리학의 일부를 수행 할 수 있다는 것입니다. 따라서 파티클 위치를 조작하는 데 사용하는 고급 물리학이 있다면 cpu 대신 gpu에서 구현하여 속도를 향상시킬 수 있는지 확인할 수 있습니다.



연습문제


1. 프로그램을 컴파일하고 실행하면 입자가 떨어지는 효과가 나타납니다.


2. 일부 기본 변수를 변경하여 입자 시스템을 수정합니다.


3. 입자에 사용되는 텍스처를 변경합니다.


4. 각 프레임마다 각 입자의 색상을 무작위로 지정합니다.


5. 빌보드 입자.


6. 입자에 코사인 움직임을 구현하여 하향 나선형 효과를 만듭니다.


7. 인스턴스화 된 파티클 시스템을 구현합니다.


8. 입자에 여러 텍스처를 사용하십시오.


9. 알파 블렌딩을 사용하지 않고 보이게 하려면 알파 블렌딩을 끄십시오.



소스코드


소스코드 :  Dx11Demo_39.zip



댓글 0

Prev 1 2 3 4 5 6 7 8 9 ··· 249 Next