# The Industry's Foundation for High Performance Graphics

1. ## 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. 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,

Jeff

3. 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. (Scene.cpp)

Code 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->SetDiffuseColour(glm::vec3(1.0, 1.0, 1.0));
skysphereTexture->SetTexture("Skybox.bmp");
skysphereTexture->SetLightPosition(_lightPosition);

Mesh *skyMesh = new Mesh();

_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

// 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

// 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);
}```

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>

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

5. ## what it looks like the the moment

[attach=config]2596[/attach]

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

#### Posting Permissions

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