Development of a particle system based on DirectX 9. Part II

This post is the 2nd and last part of an article about developing a particle system on DirectX 9. If you haven’t read the first part yet, I recommend reading it.



In this part of the article will be considered: working with sprites, vertex and pixel shaders, effects, post effects. In particular, for the implementation of the post-effect - reception of the render in the texture.

0. Basic Information

')

Sprites

Sprites are a texture that moves around the screen and depicts an object or part of an object. Since the particles in our system are just points, superimposing various textures on them can visualize any object (for example, clouds). Since the sprite is a simple texture, you need to have a basic understanding of them.



The texture instead of pixels, as we used to, has texels. Direct3D uses a coordinate system for textures formed by the horizontal axis U and the vertical axis V.

Vertex Shaders

Vertex shaders is a program that is created in a special language HLSL (or assembler), and is engaged in vertex conversion and lighting. In the vertex shader, we can take the position of the vertex and move it to a completely different place. The article vertex shader will also be used to generate texture coordinates.

Pixel Shaders

They look like vertex shaders, but instead of them they are engaged in rasterization of the image. Such a shader transmits data about texture, color and many others, and on the basis of this, the shader is obliged to return the color of the pixel. We will use them for texturing.

Effects and post effects

Effects will include pixel and / or vertex shaders, and one or more render passes. Using them you can implement, for example, the effects of blur or glow.

Post effects differ from the usual ones in that they are applied to an already cut scene.

1. Texture the particles

Before we apply the texture to the particles, we need to change the type we used to represent the vertices in the buffer to the following:

struct VertexData { float x,y,z; float u,v; //    }; 

The values ​​of u and v must be initialized to zero when created.



It is also necessary to change the flags when creating the buffer, and the description of the buffer:

 device->CreateVertexBuffer(count*sizeof(VertexData), D3DUSAGE_WRITEONLY, D3DFVF_XYZ | D3DFVF_TEX0, D3DPOOL_DEFAULT, &pVertexObject, NULL); // ... D3DVERTEXELEMENT9 decl[] = { { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, { 0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, D3DDECL_END() }; 

Add the D3DFVF_TEX0 flag, indicating that we will store the texture coordinates. We also add a string to the vertex description.



And now it remains to load the texture and change the render state:

 float pointSize = 5; //       device->SetRenderState(D3DRS_POINTSIZE_MAX, *((DWORD*)&pointSize)); device->SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&pointSize)); device->SetRenderState(D3DRS_LIGHTING,FALSE); device->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE ); //     device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1); device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); device->SetRenderState(D3DRS_ZENABLE, FALSE); 

All states will not describe, information about them can be found on MSDN. I can only say that we will need some of them for effects.

 IDirect3DTexture9 *particleTexture = NULL, D3DXCreateTextureFromFile(device, L"particle.png", &particleTexture); //  device->SetTexture(0, particleTexture); //  

Load the texture and set it from the file that will represent the particle.



Everything, now when you start the application, you will see textured particles instead of simple points, but we will go further and add a simple effect to the resulting image.



Result of visualization:

2. Effects

For the development of effects there is a great program from NVIDIA, it is called Fx Composer . Debugging shaders, shaders version 4, DIrect3D (9, 10) and OpenGL are supported. I highly recommend, but in this article this development environment will not be considered.



First, consider the basic structure of effects:





As you can see from the code, each of the shaders accepts and returns some value. The vertex shader must return the coordinates of the vertex, and the pixel color of the pixel being processed.

The effect is divided into several techniques . Each of the techniques can represent their own way of applying effects, or a different effect altogether.

Each technique has one or more visualization passes.



It is time to write your simple effect, which, for example, will paint the particles red:





The code for this effect differs little from the basic structure previously considered by us. We have added only mixing with red color by multiplication method (multiply blend). Here's what we got:





Not bad, but you can change the blend mode to another, and make blending not with one color, but with the whole texture.

In order for us to get the right mix of particle visualization and texture, we need to use a technique called Render Target (visualization target). The essence of the technique is simple, we visualize our scene in texture, and then apply effects to the already rasterized image.



Here is the full effect code of this effect:



As you noticed, there is another stage of visualization. At the first stage, we visualize particles as they are. And the visualization we will need to perform in texture. And already in the second pass of the visualization, we impose another texture on the image using Linear Light blending.

Using effects in the program

The effects we have created, it is time to change the code by adding the use of effects.

We need to create and compile an effects code, load an additional texture, and also create a texture in which we will perform visualization.





As we can see, the effect must be compiled before use, the technique must be chosen, and all the data used by it must be installed.

To render into texture we need to create the texture itself, the size of the original scene, and the surface for it. The surface will be used for visualization.



Now we only need to draw the texture using the effect. This is done like this:







In the code we used DrawRect () , this function draws a rectangle over which the RenderTexture texture is applied . This is a feature of the reception, after rendering to the texture, we need to somehow display it on the screen for further processing. This is where the rectangle helps us, which we draw so that it occupies the entire screen space. I will not give the initialization code for vertices and visualization of the rectangle, so as not to inflate the article even more. I can only say that all the necessary actions are similar to those we carried out during the initialization of particles. If you have any difficulties, you can see how this function is implemented in the example code.



The effects are used like this: first we call the Begin () method, getting the number of visualization passes in the effect. Then before each pass we call BeginPass (i) , and after EndPass () . Finally, after the end of the rendering, we call the End () method.



Here's what we got:





This article ends, thank you all for your attention. I will be glad to answer any questions you may have in the comments.

The full source code for the project is available on GitHub . Attention, to run the compiled example, you must install VisualC ++ Redistributable 2012



UPD

For those who believe that D3D9 is hopelessly outdated, or those who simply want all calculations to be made on the GPU - there is one more example, only already on D3D10. As usual, the example and compiled demo are available on GitHub . Calculations on the GPU are attached :)