基于Direct3D实现简单的粒子系统

      这是一个基于D3D的基本的粒子系统，能够实现一些基本的效果，如：雨、雪、烟花等。代码很少，只有一个头文件和一个CPP文件，便于研究粒子系统的原理。

EpParticleSystem.h:

#ifndef _EPPARTICLESYSTEM_H_
#define _EPPARTICLESYSTEM_H_

#include <d3d9.h>
#include <d3dx9.h>

struct EpParticle
{
    D3DXVECTOR3 pos ;
    float psize ;
    D3DCOLORVALUE color ;
    D3DXVECTOR3     velo ;
};

struct stParticleVertex
{
    D3DVECTOR pos ;
    float psize ;
    D3DCOLOR color ;
};

#define D3DFVF_PARTICLE (D3DFVF_XYZ | D3DFVF_PSIZE | D3DFVF_DIFFUSE)

//生成随机数
inline float rangeRand ( float min , float max );
//float->DWORD
inline DWORD FtoDW ( float val ) { return * (( DWORD * ) & val ); }

class EpParticleSystem
{
public :
    EpParticleSystem ( D3DVECTOR position , D3DVECTOR range , D3DVECTOR acceleration ,
        D3DVECTOR emitterPositionMin , D3DVECTOR emitterPositionMax ,
        D3DVECTOR velocityMin , D3DVECTOR velocityMax ,
        D3DCOLORVALUE colorMin , D3DCOLORVALUE colorMax ,
        float psizeMin , float psizeMax ,
        int maxCount , int emitCount , float emitInterval ,
        LPDIRECT3DDEVICE9 device , LPDIRECT3DTEXTURE9 texture );
    virtual ~ EpParticleSystem ();
    bool Initialize ();
    void Update ( float delta );
    bool Render ();

protected :
    void emit ( int emitCount );

protected :
    D3DXVECTOR3 m_Pos ;        //位置
    D3DXVECTOR3 m_Range ;    //范围
    D3DXVECTOR3 m_Accel ;    //加速度
    D3DXVECTOR3 m_EmiPosMin , m_EmiPosMax ;    //发射器位置
    D3DXVECTOR3 m_VeloMin , m_VeloMax ;        //粒子速度
    D3DCOLORVALUE m_ColorMin , m_ColorMax ;    //颜色
    float m_PSizeMin , m_PSizeMax ;            //粒子大小
    int m_Count , m_MaxCount ;        //粒子数量及上限
    int m_EmiCount ; float m_EmiInterval ;            //发射数量,发射间隔时间
    float m_Interval ;            //累计时间

    EpParticle * m_Particles ;        //粒子池

    LPDIRECT3DDEVICE9 m_pDevice ;    //设备对象
    LPDIRECT3DTEXTURE9 m_pTexture ;    //纹理
    LPDIRECT3DVERTEXBUFFER9 m_pVB ;    //顶点缓冲区

    D3DXMATRIX m_WorldMat ;        //世界转换矩阵
};
#endif

EpParticleSystem.cpp:

#include "EpParticleSystem.h"
#include <stdlib.h>
#include <time.h>


EpParticleSystem :: EpParticleSystem ( D3DVECTOR position , D3DVECTOR range ,
    D3DVECTOR acceleration , D3DVECTOR emitterPositionMin , D3DVECTOR emitterPositionMax ,
    D3DVECTOR velocityMin , D3DVECTOR velocityMax , D3DCOLORVALUE colorMin ,
    D3DCOLORVALUE colorMax , float psizeMin , float psizeMax ,
    int maxCount , int emitCount , float emitInterval ,
    LPDIRECT3DDEVICE9 device , LPDIRECT3DTEXTURE9 texture )
{
    m_Pos = position ;
    m_Range = range ;
    m_Accel = acceleration ;
    m_EmiPosMin = emitterPositionMin ;
    m_EmiPosMax = emitterPositionMax ;
    m_VeloMin = velocityMin ;
    m_VeloMax = velocityMax ;
    m_ColorMin = colorMin ;
    m_ColorMax = colorMax ;
    m_PSizeMin = psizeMin ;
    m_PSizeMax = psizeMax ;
    m_Count     = 0 ;
    m_MaxCount = maxCount ;
    m_EmiCount = emitCount ;
    m_EmiInterval = emitInterval ;
    m_Interval = 0.0f ;
    m_pDevice = device ;
    m_pTexture = texture ;
    m_Particles = NULL ;
    m_pVB = NULL ;
    //随机数种子
    srand ( ( unsigned ) time ( NULL ) );
    //计算世界矩阵
    D3DXMatrixTranslation ( & m_WorldMat , m_Pos . x , m_Pos . y , m_Pos . z );
}

bool EpParticleSystem :: Initialize ()
{
    if ( m_pDevice == NULL )
    {
        return false ;
    }
    //构建粒子池
    m_Particles = new EpParticle [ m_MaxCount ];
    if ( m_Particles == NULL )
    {
        return false ;
    }
    //创建顶点缓冲区
    if ( FAILED ( m_pDevice -> CreateVertexBuffer ( sizeof ( stParticleVertex ) * m_MaxCount ,
        D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY | D3DUSAGE_POINTS ,
        D3DFVF_PARTICLE , D3DPOOL_DEFAULT , & m_pVB , NULL )))
        return false ;

    return true ;
}

void EpParticleSystem :: Update ( float delta )
{
    EpParticle * p = NULL ;
    for ( int i = 0 ; i < m_Count ; i ++ )
    {    
        //改变粒子的速度与位置
        p = & m_Particles [ i ];
        p -> pos += p -> velo ;
        p -> velo += m_Accel ;

        //检查粒子是否超出边界
        if ( ! (p -> pos . x <= m_Range . x / 2 && p -> pos . x >= - m_Range . x / 2 &&
              p -> pos . y <= m_Range . y / 2 && p -> pos . y >= - m_Range . y / 2 &&
              p -> pos . z <= m_Range . z / 2 && p -> pos . z >= - m_Range . z / 2 ))
        {
            //将最后一个粒子移到该位置
            m_Particles [ i ] = m_Particles [ m_Count - 1 ];
            m_Count -- ;    //抛弃最后一个粒子
            i -- ;    //重新检查该粒子
        }
    }
    //发射粒子
    m_Interval += delta ;
    if ( m_Interval >= m_EmiInterval )
    {    
        emit ( m_EmiCount );
        m_Interval -= m_EmiInterval ;
    }
}
//生成随机数
float rangeRand ( float min , float max )
{
    return ( float ) rand () / RAND_MAX * ( max - min ) + min ;
}
//发射一定数量的粒子
void EpParticleSystem :: emit ( int emitCount )
{
    EpParticle * p = NULL ;
    for ( int i = 0 ; i < emitCount ; i ++ )
    {    
        if ( m_Count == m_MaxCount ) break ;
        p = & m_Particles [ m_Count ];
        p -> pos . x = rangeRand ( m_EmiPosMin . x , m_EmiPosMax . x );
        p -> pos . y = rangeRand ( m_EmiPosMin . y , m_EmiPosMax . y );
        p -> pos . z = rangeRand ( m_EmiPosMin . z , m_EmiPosMax . z );
        p -> velo . x = rangeRand ( m_VeloMin . x , m_VeloMax . x );
        p -> velo . y = rangeRand ( m_VeloMin . y , m_VeloMax . y );
        p -> velo . z = rangeRand ( m_VeloMin . z , m_VeloMax . z );
        p -> psize = rangeRand ( m_PSizeMin , m_PSizeMax );
        p -> color . r = rangeRand ( m_ColorMin . r , m_ColorMax . r );
        p -> color . g = rangeRand ( m_ColorMin . g , m_ColorMax . g );
        p -> color . b = rangeRand ( m_ColorMin . b , m_ColorMax . b);
        p -> color . a = rangeRand ( m_ColorMin . a , m_ColorMax . a );
        m_Count ++ ;
    }
}

bool EpParticleSystem :: Render ()
{
    if ( m_Count == 0 )
    {
        return true ;
    }
    //将粒子从粒子池转移到顶点缓冲区
    stParticleVertex * p;
    if ( FAILED ( m_pVB -> Lock ( 0 , sizeof ( stParticleVertex ) * m_Count , ( void ** ) & p , 0 )))
        return false ;

    for ( int i = 0 ; i < m_Count ; i ++ )
    {
        p [ i ]. pos = m_Particles [ i ]. pos ;
        p [ i ]. psize = m_Particles [ i ]. psize ;
        p [ i ]. color = D3DCOLOR_COLORVALUE ( m_Particles [ i ]. color . r ,
            m_Particles [ i ]. color . g , m_Particles [ i ]. color . b , m_Particles [ i ]. color . a );
    }

    m_pVB -> Unlock ();

    m_pDevice -> SetTransform ( D3DTS_WORLD , & m_WorldMat );
    m_pDevice -> SetTexture ( 0 , m_pTexture );
    m_pDevice -> SetRenderState ( D3DRS_LIGHTING , FALSE );
    m_pDevice -> SetRenderState ( D3DRS_ALPHABLENDENABLE , TRUE );
    m_pDevice -> SetRenderState ( D3DRS_DESTBLEND , D3DBLEND_ONE );
    m_pDevice -> SetRenderState ( D3DRS_POINTSPRITEENABLE , TRUE );
    m_pDevice -> SetRenderState ( D3DRS_POINTSCALEENABLE , TRUE );
    m_pDevice -> SetRenderState ( D3DRS_POINTSCALE_A , FtoDW ( 0.0f ));
    m_pDevice -> SetRenderState ( D3DRS_POINTSCALE_B , FtoDW ( 0.0f ));
    m_pDevice -> SetRenderState ( D3DRS_POINTSCALE_C , FtoDW ( 10.0f ));
   
    m_pDevice -> SetFVF ( D3DFVF_PARTICLE );
    m_pDevice -> SetStreamSource ( 0 , m_pVB , 0 , sizeof ( stParticleVertex ));
    m_pDevice -> DrawPrimitive ( D3DPT_POINTLIST , 0 , m_Count );

    m_pDevice -> SetRenderState ( D3DRS_LIGHTING , TRUE );
    m_pDevice -> SetRenderState ( D3DRS_ALPHABLENDENABLE , FALSE );
    m_pDevice -> SetRenderState ( D3DRS_POINTSPRITEENABLE , FALSE );

    return true ;
}

EpParticleSystem ::~ EpParticleSystem ()
{
    if ( m_Particles != NULL )
    {
        delete [] m_Particles ;
        m_Particles = NULL ;
    }
    if ( m_pVB != NULL )
    {
        m_pVB -> Release ();
        m_pVB = NULL ;
    }
}

下面一个文件是使用这个粒子系统实现一个烟火效果的例子。

main.cpp

#include <d3d9.h>
#include <d3dx9.h>
#include "EpParticleSystem.h"

#define WINDOW_CLASS    "MyWndCls"
#define WINDOW_NAME     "Particle System Test"
#define WINDOW_WIDTH    800
#define WINDOW_HEIGHT   600
#define FULLSCREEN      FALSE

bool InitializeD3D ( HWND hWnd , bool fullscreen );
bool InitializeObjects ();
void RenderScene ();
void Shutdown ();

LPDIRECT3D9 g_D3D = NULL ;
LPDIRECT3DDEVICE9 g_D3DDevice = NULL ;

D3DXMATRIX g_ProjMat ;    //投影矩阵
D3DXMATRIX g_ViewMat ;    //视图矩阵

LPDIRECT3DTEXTURE9 g_Texture = NULL ;    //用于粒子的纹理

EpParticleSystem * g_Firework = NULL ;    //粒子系统

float g_LastTime = 0.0f ;    //用于计算时间增量
float g_Time = 0.0f ;

LRESULT WINAPI MsgProc ( HWND hWnd , UINT msg , WPARAM wParam , LPARAM lParam )
{
    switch ( msg )
    {
    case WM_DESTROY:
        PostQuitMessage ( 0 );
        return 0 ;
        break ;

    case WM_KEYUP:
        if ( wParam == VK_ESCAPE )
            PostQuitMessage ( 0 );
        break ;
    }

    return DefWindowProc ( hWnd , msg , wParam , lParam );
}

int WINAPI WinMain ( HINSTANCE hInst , HINSTANCE prevhInst , LPSTR cmdLine , int show )
{
    WNDCLASSEX wc = { sizeof ( WNDCLASSEX ), CS_CLASSDC , MsgProc , 0L , 0L ,
        GetModuleHandle ( NULL ), NULL , LoadCursor ( NULL , IDC_ARROW ), NULL , NULL ,
        WINDOW_CLASS , NULL };
    RegisterClassEx ( & wc );

    HWND hWnd = CreateWindow ( WINDOW_CLASS , WINDOW_NAME , WS_POPUP ,
        100 , 100 , WINDOW_WIDTH , WINDOW_HEIGHT ,
        NULL , NULL , wc . hInstance , NULL );

    if ( InitializeD3D ( hWnd , FULLSCREEN ))
    {
        ShowWindow ( hWnd , show );
        UpdateWindow ( hWnd );

        MSG msg = { 0 };

        while ( msg . message != WM_QUIT )
        {
            if ( PeekMessage ( & msg , NULL , 0 U , 0 U , PM_REMOVE ))
            {
                TranslateMessage ( & msg );
                DispatchMessage ( & msg );
            }
            else
                RenderScene ();
        }
    }

    Shutdown ();

    UnregisterClass ( WINDOW_CLASS , wc . hInstance );
    return 0 ;
}

bool InitializeD3D ( HWND hWnd , bool fullscreen )
{
    D3DDISPLAYMODE displayMode ;

    g_D3D = Direct3DCreate9 ( D3D_SDK_VERSION );
    if ( g_D3D == NULL ) return false ;

    if ( FAILED ( g_D3D -> GetAdapterDisplayMode ( D3DADAPTER_DEFAULT , & displayMode )))
        return false ;

    D3DPRESENT_PARAMETERS d3dpp = { 0 };

    if ( fullscreen )
    {
        d3dpp . Windowed = FALSE ;
        d3dpp . BackBufferWidth = WINDOW_WIDTH ;
        d3dpp . BackBufferHeight = WINDOW_HEIGHT ;
    }
    else
        d3dpp . Windowed = TRUE ;
    d3dpp . SwapEffect = D3DSWAPEFFECT_DISCARD ;
    d3dpp . BackBufferFormat = displayMode . Format ;

    if ( FAILED ( g_D3D -> CreateDevice ( D3DADAPTER_DEFAULT , D3DDEVTYPE_HAL , hWnd ,
        D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE ,
        & d3dpp , & g_D3DDevice ))) return false ;

    if ( ! InitializeObjects ()) return false ;

    return true ;
}

bool InitializeObjects ()
{
    //加载纹理
    if ( D3DXCreateTextureFromFile ( g_D3DDevice , "snow.tga" , & g_Texture ) != D3D_OK )
        return false ;
   
    D3DVECTOR position = D3DXVECTOR3 ( 0.0f , 0.0f , 0.0f );    //粒子系统的位置
    D3DVECTOR range = D3DXVECTOR3 ( 4.0f , 4.0f , 4.0f );    //长宽高范围
    D3DVECTOR accel = D3DXVECTOR3 ( 0.0f , - 0.0002f , 0.0f );    //加速度
    D3DVECTOR emiPosMin = D3DXVECTOR3 ( - 0.05f , - 2.0f , - 0.05f );    //发射位置的范围
    D3DVECTOR emiPosMax = D3DXVECTOR3 ( 0.05f , - 2.0f , 0.05f );
    D3DXVECTOR3 veloMin = D3DXVECTOR3 ( - 0.006f , 0.02f , - 0.006f );    //粒子初始速度范围
    D3DXVECTOR3 veloMax = D3DXVECTOR3 ( 0.006f , 0.03f , 0.006f );
    D3DCOLORVALUE colorMin = { 0.0f , 0.0f , 0.0f , 0.0f };         //粒子颜色范围
    D3DCOLORVALUE colorMax = { 1.0f , 1.0f , 1.0f , 0.0f };
    float psizeMin = 0.3f ;    //粒子大小范围
    float psizeMax = 0.5f ;
    int maxCount = 3000 ;    //最大粒子数量
    int emiCount = 10 ;    //每次发射数量
    float emiInterval = 0.01f ; //发射间隔时间
    g_Firework = new EpParticleSystem ( position , range , accel , emiPosMin , emiPosMax ,
        veloMin , veloMax , colorMin , colorMax , psizeMin , psizeMax , maxCount , emiCount , emiInterval ,
        g_D3DDevice , g_Texture );
    //初始化粒子系统
    g_Firework -> Initialize ();

    g_D3DDevice -> SetSamplerState ( 0 , D3DSAMP_MINFILTER , D3DTEXF_ANISOTROPIC );
    g_D3DDevice -> SetSamplerState ( 0 , D3DSAMP_MAGFILTER , D3DTEXF_ANISOTROPIC );

    //计算投影矩阵
    D3DXMatrixPerspectiveFovLH ( & g_ProjMat , 45.0f , 4.0f / 3 , 0.1f , 1000.0f );
    g_D3DDevice -> SetTransform ( D3DTS_PROJECTION , & g_ProjMat );

    //计算视图矩阵
    D3DXVECTOR3 cameraPos ( 0.0f , 0.0f , - 3.0f );
    D3DXVECTOR3 lookAtPos ( 0.0f , - 1.0f , 0.0f );
    D3DXVECTOR3 upDir ( 0.0f , 1.0f , 0.0f );
    D3DXMatrixLookAtLH ( & g_ViewMat , & cameraPos , & lookAtPos , & upDir );
    g_D3DDevice -> SetTransform ( D3DTS_VIEW , & g_ViewMat );

    return true ;
}

void RenderScene ()
{
    //计算时间增量
    g_Time = GetTickCount () * 0.001f ;
    float interval = g_Time - g_LastTime ;
    g_LastTime = g_Time ;
   
    g_Firework -> Update ( interval );

    g_D3DDevice -> Clear ( 0 , NULL , D3DCLEAR_TARGET , D3DCOLOR_XRGB ( 0 , 0 , 0 ), 1.0f , 0 );

    g_D3DDevice -> BeginScene ();

    g_Firework -> Render ();

    g_D3DDevice -> EndScene ();

    g_D3DDevice -> Present ( NULL , NULL , NULL , NULL );
}


void Shutdown ()
{
    if ( g_D3DDevice != NULL ) g_D3DDevice -> Release ();
    g_D3DDevice = NULL ;

    if ( g_D3D != NULL ) g_D3D -> Release ();
    g_D3D = NULL ;

    if ( g_Texture != NULL ) g_Texture -> Release ();
    g_Texture = NULL ;

    if ( g_Firework != NULL ) delete g_Firework ;
    g_Firework = NULL ;
}

实现的效果如下：

      这个粒子系统还很原始，在创建的时候需要传入太多的参数，并且只能硬编码，今后可以增加对脚本的支持。此外还有很多局限，比如粒子系统的范围只能是一个立方体，而实际需求可能会是圆柱体等形状。当前的粒子系统创建后不能移动，也不能修改其他参数，只能使用一个加速度，粒子的颜色不能衰减，粒子不能自行湮灭，只能移动到区域外被回收，只能使用单一的纹理等，这些都是需要改进的地方。

 

       所用的纹理下载：http://download.csdn.net/source/1656023

       源代码下载：http://download.csdn.net/source/1656048