Part of the Khronos Group

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 6 of 6

Thread: Particle system help

  1. #1
    Junior Member Newbie
    Join Date
    Jan 2018

    Particle system help

    I have been going through the web trying to find the method to make a texture based instance particle system. I can make a window with a camera pan, but would like to have a functional particle system.

  2. #2
    Junior Member Regular Contributor
    Join Date
    Dec 2016
    Ocean Shores, WA USA
    I have been devoting several videos on my opengl tutorial youtube channel to just that purpose! My favorite programming challenge / hobby is playing with particle systems!

    I implement particle systems two main ways: 1) Drawing Textures on Quads, and 2) Drawing Textures on Point Sprites.

    For the #2 method, here's the video showing how to enable point sprites:

    and here's the video showing the first particle system:

    ... and this is one using the quads method...

    I am just learning too, and if you have any requests for videos, please let me know, anything that I can research and make a tutorial video for, would be great! Thanks,

    Let me know what you think,

    Last edited by OceanJeff40; 01-09-2018 at 11:13 PM.

  3. #3
    Junior Member Newbie
    Join Date
    Jan 2018
    I Have checked out your tutorials they seem good gonna subscribe. one thing I would like to know is the whole shader.txt and vertex.txt in notepad at the moment i am working with a camera that is stuck on a fixed angle i can post the code if needed. Have to have something done before friday.

  4. #4
    Junior Member Newbie
    Join Date
    Jan 2018

    Code cpp:
    #include "Scene.h"
    #include <iostream>
    #include <SDL/SDL.h>
        _cameraAngleX = 0.3f, _cameraAngleY = 1.5f;
        // Set up the viewing matrix
        // This represents the camera's orientation and position
        _viewMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0,0,-3.5f) );
        // Set up a projection matrix
        _projMatrix = glm:erspective(45.0f, 1.0f, 0.1f, 100.0f);
        // Set up your scene here
    //skybox setup
        _skysphere = new GameObject();
        Material *skysphereTexture = new Material();
        skysphereTexture->LoadShaders("VertShader.txt", "FragShader.txt");
        skysphereTexture->SetDiffuseColour(glm::vec3(1.0, 1.0, 1.0));
        Mesh *skyMesh = new Mesh();
        // Position of the light, in world-space
        _lightPosition = glm::vec3(10,10,0);
        // Create a game object
        // This needs a material and a mesh
        _model = new GameObject();
        _fountain = new GameObject();
        // Create the material for the game object
        Material *modelMaterial = new Material();
        Material *fountainMaterial = new Material();
        // Shaders are now in files
        fountainMaterial->LoadShaders("VertShader.txt", "FragShader.txt");
        // You can set some simple material properties, these values are passed to the shader
        // This colour modulates the texture colour
        modelMaterial->SetDiffuseColour( glm::vec3(1.0f,1.0f,1.0f) );
        fountainMaterial->SetDiffuseColour( glm::vec3(1.0f,1.0f,1.0f) );
        // The material currently supports one texture
        // This is multiplied by all the light components (ambient, diffuse, specular)
        // Note that the diffuse colour set with the line above will be multiplied by the texture colour
        // If you want just the texture colour, use modelMaterial->SetDiffuseColour( glm::vec3(1,1,1) );
        // Need to tell the material the light's position
        // If you change the light's position you need to call this again
        // Tell the game object to use this material
        // The mesh is the geometry for the object
        Mesh *modelMesh = new Mesh();
        Mesh *fountainMesh = new Mesh();
        // Load from OBJ file. This must have triangulated geometry
        // Tell the game object to use this mesh
        _fountain->SetPosition(0, -3, 0);
        // You should neatly clean everything up here
    void Scene::Update( float deltaTs )
        // Update the game object (this is currently hard-coded to rotate)
        _model->Update( deltaTs );
        // This updates the camera's position and orientation
        _viewMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0, 0, -11.0f)); // Provides offset away from player object
        _viewMatrix = glm::rotate(_viewMatrix, _cameraAngleX, glm::vec3(1, 0, 0)); // Allows player to rotate camera using player object as pivot
        _viewMatrix = glm::rotate(_viewMatrix, _cameraAngleY, glm::vec3(0, 1, 0));
    void Scene::Draw()
        // Draw that model, giving it the camera's position and projection
        _skysphere->Draw(_viewMatrix, _projMatrix);
        _fountain->Draw(_viewMatrix, _projMatrix);

    Code glsl:
    ##version 430 core vert shader.txt
    // Per-vertex inputs
    layout(location = 0) in vec4 vPosition;
    layout(location = 1) in vec3 vNormalIn;
    layout(location = 2) in vec2 vTexCoordIn;
    // Uniform data inputs are the same for all vertices
    uniform mat4 modelMat;
    uniform mat4 invModelMat;
    uniform mat4 viewMat;
    uniform mat4 projMat;
    uniform vec4 worldSpaceLightPos = {1,0.0,1,1};
    // These per-vertex outputs must correspond to the per-fragment inputs in the fragment shader
    out vec3 vNormalV;
    out vec3 eyeSpaceLightPosV;
    out vec3 eyeSpaceVertPosV;
    out vec2 texCoord;
    void main()
        // Perform vertex transformations
        gl_Position = projMat * viewMat * modelMat * vPosition;
        // Vector from eye to vertex position, in eye-space
        eyeSpaceVertPosV = vec3(viewMat * modelMat * vPosition);
        // Vector from vertex position to light position, in eye-space
        eyeSpaceLightPosV = vec3(viewMat * worldSpaceLightPos);
        // Vertex normal, in eye-space
        vNormalV = mat3(viewMat * modelMat) * vNormalIn;
        // Pass through the texture coordinate
        texCoord = vTexCoordIn;

    Code glsl:
    #version 430 core frag shader
    // Input per-fragment data
    // These must correspond to the varying outputs from the vertex shader
    in vec3 vNormalV;
    in vec3 eyeSpaceLightPosV;
    in vec3 eyeSpaceVertPosV;
    in vec2 texCoord;
    // Input uniform data - these have values that will be the same for every fragment
    uniform vec3 lightColour = {0.8,0.8,0.8};
    uniform vec3 emissiveColour = {0,0,0};
    uniform vec3 ambientColour = {0.1f,0.1f,0.2f};
    uniform vec3 diffuseColour = {1.0f,1.0f,1.0f};
    uniform vec3 specularColour = {1.0f,1.0f,1.0f};
    uniform float shininess = 50.0f;
    uniform float alpha = 1.0f;
    // The output of the fragment shader is the fragment's colour
    out vec4 fragColour;
    // This is another input to allow us to access a texture
    uniform sampler2D tex1;
    void main()
        // Calculate the direction from the sample position to the light
        vec3 lightDir = normalize( eyeSpaceLightPosV - eyeSpaceVertPosV );
        // Ensure the normal is a unit vector
        vec3 normal = normalize( vNormalV );
        // Direction from eye to sample point
        vec3 eyeDir = normalize( -eyeSpaceVertPosV );
        // Vector half way between one to eye and one to light
        vec3 halfVec = normalize( eyeDir + lightDir );
        // Retrieve colour from texture
        vec3 texColour = vec3(texture(tex1,vec2(texCoord.x,1-texCoord.y)));
        // Calculate diffuse lighting
        vec3 diffuse = diffuseColour * lightColour * max( dot( normal, lightDir ), 0);
        // Put specular lighting code here!
        vec3 specular = vec3(0);
        // Final colour uses the texture colour for all components
        // If you want a separate texture for specular you will need to change this
        fragColour = vec4( emissiveColour + texColour*(ambientColour + diffuse + specular), alpha);

    Particle bit

    Code cpp:
    #include "Particle.h"
    #include "glew.h"
    #include <iostream>
    #include <SDL/SDL.h>
    #include <GLM/glm.hpp>
    #include <GLM/gtc/matrix_transform.hpp>
    #include <string>
    #include <GLM/glm.hpp>
    #include "glew.h"
    #include <GLM\matrix.hpp>
    #include <GLM/gtc/matrix_transform.hpp>
    class Particle

    Last edited by Dark Photon; 01-11-2018 at 04:36 PM.

  5. #5
    Junior Member Newbie
    Join Date
    Jan 2018

    what it looks like the the moment

    [attach=config]2596[/Click image for larger version. 

Name:	Tech demo fountain.jpg 
Views:	42 
Size:	18.2 KB 
ID:	2596attach]

  6. #6
    Administrator Regular Contributor Khronos_webmaster's Avatar
    Join Date
    Apr 2007
    Be sure to use the [ code ] [ / code ] tags when posting your code. Especially when posting large amounts of code.
    Webmaster and

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts