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.

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,


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.


#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);

##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;

#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

#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




Be sure to use the [ code ] [ / code ] tags when posting your code. Especially when posting large amounts of code.