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!
https://www.youtube.com/channel/UCzx8alrxVELz5h1dfCdkdfg
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:
https://www.youtube.com/watch?v=X1sCoPxJJW8
and here’s the video showing the first particle system:
https://www.youtube.com/watch?v=aazlw_Hs6o4
… and this is one using the quads method…
https://www.youtube.com/watch?v=V976PVA-D2w
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,
Jeff
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.
(Scene.cpp)
#include "Scene.h"
#include <iostream>
#include <SDL/SDL.h>
Scene::Scene()
{
_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));
skysphereTexture->SetTexture("Skybox.bmp");
skysphereTexture->SetLightPosition(_lightPosition);
Mesh *skyMesh = new Mesh();
skyMesh->LoadOBJ("SkySphere.obj");
_skysphere->SetMesh(skyMesh);
_skysphere->SetMaterial(skysphereTexture);
// 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
modelMaterial->LoadShaders("VertShader.txt","FragShader.txt");
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) );
modelMaterial->SetTexture("TeapotColourMap.bmp");
fountainMaterial->SetTexture("Fountain.bmp");
// Need to tell the material the light's position
// If you change the light's position you need to call this again
modelMaterial->SetLightPosition(_lightPosition);
fountainMaterial->SetLightPosition(_lightPosition);
// Tell the game object to use this material
_model->SetMaterial(modelMaterial);
_fountain->SetMaterial(fountainMaterial);
// 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
modelMesh->LoadOBJ("teapot3.obj");
fountainMesh->LoadOBJ("Fountain.obj");
// Tell the game object to use this mesh
_model->SetMesh(modelMesh);
_fountain->SetMesh(fountainMesh);
_fountain->SetPosition(0, -3, 0);
}
Scene::~Scene()
{
// 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 );
_skysphere->Update(deltaTs);
_fountain->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
//_model->Draw(_viewMatrix,_projMatrix);
_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>
Particle::Particle()
{
}
Particle::~Particle()
{
}
#include <string>
#include <GLM/glm.hpp>
#include "glew.h"
#include <GLM\matrix.hpp>
#include <GLM/gtc/matrix_transform.hpp>
class Particle
{
Particle();
~Particle();
};
SOME HELP WOULD BE MUCH APPRECIATED
[attach=config]2596[/[ATTACH=config]1655[/ATTACH]attach]
Be sure to use the [ code ] [ / code ] tags when posting your code. Especially when posting large amounts of code.