As part of my time at FIEA, the programmers are tasked with a personal programming project. I chose to create a particle system using directx. I also want to create a C# tool that can edit the particle system in real time by creating a C++/CLI bridge. The bridge will allow the tool to run the C++ code of the particle system. 

​

I was able to create the particle system using a vertex and pixel shadder. The code is below:
cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};

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;
    

    // Change the position vector to be 4 units for proper matrix calculations.
    input.position.w = 1.0f;

    // Calculate the position of the vertex against the world, view, and projection matrices.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    // Store the texture coordinates for the pixel shader.
    output.tex = input.tex;
    
    // Store the particle color for the pixel shader. 
    output.color = input.color;

    return output;
}

​

// Pixel Shader
float4 ParticlePixelShader(PixelInputType input) : SV_TARGET
{
    float4 textureColor;
    float4 finalColor;

    // Sample the pixel color from the texture using the sampler at this texture coordinate location.
    textureColor = shaderTexture.Sample(SampleType, input.tex);

    // Combine the texture color and the particle color to get the final color result.
    finalColor = textureColor * input.color;

    return finalColor;
}

​

Here is my particle shadder class:

class ParticleShader
    {
    private:
        struct MatrixBufferType
        {
            D3DXMATRIX world;
            D3DXMATRIX view;
            D3DXMATRIX projection;
        };

    public:
        ParticleShader();
        ParticleShader(const ParticleShader&);
        ~ParticleShader();

        bool Initialize(ID3D11Device*, HWND);
        void Shutdown();
        bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*);

    private:
        bool InitializeShader(ID3D11Device*, HWND, LPCSTR, LPCSTR);
        void ShutdownShader();
        void OutputShaderErrorMessage(ID3D10Blob*, HWND, LPCSTR);

        bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*);
        void RenderShader(ID3D11DeviceContext*, int);

    private:
        ID3D11VertexShader* m_vertexShader;
        ID3D11PixelShader* m_pixelShader;
        ID3D11InputLayout* m_layout;
        ID3D11Buffer* m_matrixBuffer;
        ID3D11SamplerState* m_sampleState;
    };

​

class ParticleSystem
    {
    private:
        struct ParticleType
        {
            float positionX, positionY, positionZ;
            float red, green, blue;
            float velocity;
            bool active;
        };

        struct VertexType
        {
            D3DXVECTOR3 position;
            D3DXVECTOR2 texture;
            D3DXVECTOR4 color;
        };

    public:
        ParticleSystem();
        ParticleSystem(const ParticleSystem&);
        ~ParticleSystem();

        bool Initialize(ID3D11Device*, LPCSTR);
        void Shutdown();
        bool Frame(float, ID3D11DeviceContext*);
        void Render(ID3D11DeviceContext*);

        ID3D11ShaderResourceView* GetTexture();
        int GetIndexCount();

    private:
        bool LoadTexture(ID3D11Device*, LPCSTR);
        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, m_particleDeviationY, m_particleDeviationZ;
        float m_particleVelocity, m_particleVelocityVariation;
        float m_particleSize, m_particlesPerSecond;
        int m_maxParticles;

        int m_currentParticleCount;
        float m_accumulatedTime;

        Texture* m_Texture;
        ParticleType* m_particleList;
        int m_vertexCount, m_indexCount;
        VertexType* m_vertices;
        ID3D11Buffer *m_vertexBuffer, *m_indexBuffer;
    };

​

I am currently using directx 9 by the use of d3d so I am working on moving this to directx11.