I was wondering what you guys think the best course of action would be

I'm looking to making a particle system. Currently I have a sprite batcher that can handle rotations, scaling, and etc. It works by mapping a VBO with vertex data I need for the sprites I want to draw. Now I'm wondering should I just build my particle system on top of this? Or should I create a whole new system that uses instancing? Would a instance system even be better, would it even help? I ask because I really do not know that much about instancing

Does any of this change if want to be able to do effects such as rain, snow, fire, smoke?

What if I want the particles to be textured, eg each particle is a different snowflake image?

I'm targeting OpenGL 3.3+ just as fyi too

So if I make them separate (my batcher and the particle system), I hope this makes sense, then I'm looking at

1 static buffer for my vertex coords [5 floats (x,y,z, uText, vText) * 4 (since it is a quad)] thats filled at init

1 static buffer for my indices [ 6 floats]

1 dynamic buffer for my particle positions [2 floats (x,y) * the max number of particles] that is filled/changes every frame

Then I can use the glDrawElementsInstanced call to draw the number of particles to the screen

That makes sense right?

So my question is should I even bother with a new system?

My current sprite batcher system is already dynamic and uses glDrawElementsBaseVertex to get things done.

It made sense to make a new system if I was going to use instancing, but since you and the slides say don't use DrawInstanced.

Making a particle system based on instancing does not make any sense

Instancing is likely more performant than batching (sending 1 vertex instead of 4 per particle). It's also a good exercise - that's how I learned instancing with DX9 .

Edit: You can also delegate more to the GPU, in particular: Grant your vertex a scale and rotation and do that in the vertex shader.

#version 330 core

in vec2 xyPosition;
out vec2 UV;
uniform mat4 MVP; //orthographic projection matrix passed in

void main()
{
	//For 1x1 sized particle
	vec4 vertexPosition;
	int vertex = gl_VertexId % 4;
	if(vertex == 0)
	{
		vertexPosition.x = 0;
		vertexPosition.y = 0;
	}
	else if(vertex == 1)
	{
		vertexPosition.x = 0;
		vertexPosition.y = 1;
	}
	else if(vertex == 2)
	{
		vertexPosition.x = 1;
		vertexPosition.y = 1;
	}
	else if(vertex == 3)
	{
		vertexPosition.x = 1;
		vertexPosition.y = 0;
	}
	vertexPosition.z = 0;
	vertexPosition.w = 1;
	
	gl_Position = MVP * vertexPosition;
	UV = uvPosition;
}

1 dynamic UBO or TBO for your particle position [2 floats(x, y) * max number of particles].
Use gl_VertexId in the vertex shader to construct the quad.

By setting a null vbo and draw 4 vertices (1 particle), you're basically telling the api "draw 4 vertices of nothing" (aka iterate the vertex shader 4 times with no vertex data) but the vertex shader can fetch data from a different location (the ubo) with the help of gl_vertexid to determine the index in the ubo and the vertex position to generate.

//Example contents of my buffer for 2 quads

const int FLOATS_PER_QUAD = 8; // 4 vertex * 2 (x, y positions)
int maxParticles = 2;
GLfloat *vertex = new GLfloat[maxParticles * FLOATS_PER_QUAD];

//Quad 1 at position 50x50
vertex[0] = 50.0f; //X pos
vertex[1] = 50.0f; //Y pos
vertex[2] = 50.0f; 
vertex[3] = 50.0f; 
vertex[4] = 50.0f; 
vertex[5] = 50.0f; 
vertex[6] = 50.0f; 
vertex[7] = 50.0f; 

//Quad 2 at position 25x40
vertex[8] = 25.0f; //X pos
vertex[9] = 40.0f; //Y pos
vertex[10] = 25.0f; 
vertex[11] = 40.0f; 
vertex[12] = 25.0f; 
vertex[13] = 40.0f; 
vertex[14] = 25.0f; 
vertex[15] = 40.0f; 

//The contents of my buffer for 2 quads

const int POSITION_COMP_COUNT = 2; // For XY position
int maxParticles = 2;
GLfloat *vertex = new GLfloat[maxParticles * POSITION_COMP_COUNT];

//Quad 1 at position 50x50
vertex[0] = 50.0f; //X pos
vertex[1] = 50.0f; //Y pos

//Quad 2 at position 25x40
vertex[3] = 25.0f; //X pos
vertex[4] = 40.0f; //Y pos