Uniforms in SFML GLEW C++

main.cpp

#include <GL/glew.h>
#include <SFML/Graphics.hpp>
#include <iostream>
#include <math.h>


const char* vertexShaderSource = 
	"#version 330 core\n"
	"layout (location = 0) in vec3 position;\n"
	"void main() {\n"
	"	gl_Position = vec4(position.x, position.y, position.z, 1.0);\n"
	"};\0";

const char* fragmentShaderSource0 =
	"#version 330 core\n"
	"out vec4 color;\n"
	"uniform float color0;\n"
	"void main() {\n"
	"	color = vec4(color0, 0.0, 0.0, 1.0);\n"
	"};\0";

const char* fragmentShaderSource1 =
	"#version 330 core\n"
	"out vec4 color;\n"
	"uniform vec4 color1;\n"
	"void main() {\n"
	"	color = color1;\n"
	"};\0";

GLint vertexBool;
GLint fragmentBool0;
GLint fragmentBool1;


int main() {

	sf::RenderWindow window(sf::VideoMode(400, 400), "Alex Mercer", sf::Style::Default);
	window.setFramerateLimit(60);
	sf::Clock clock;

	glewInit();

	GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShaderID, 1, &vertexShaderSource, NULL);
	glCompileShader(vertexShaderID);
	glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &vertexBool);

	GLuint fragmentShaderID0 = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShaderID0, 1, &fragmentShaderSource0, NULL);
	glCompileShader(fragmentShaderID0);
	glGetShaderiv(fragmentShaderID0, GL_COMPILE_STATUS, &fragmentBool0);

	GLuint fragmentShaderID1 = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShaderID1, 1, &fragmentShaderSource1, NULL);
	glCompileShader(fragmentShaderID1);
	glGetShaderiv(fragmentShaderID1, GL_COMPILE_STATUS, &fragmentBool1);

	if (vertexBool && fragmentBool0 && fragmentBool1) {
		std::cout << "Vertex and fragment shaders successfully compiled." << std::endl;
	}
	else {
		std::cout << "Vertex and fragment shaders could not be compiled." << std::endl;
	};

	GLuint shaderProgram0 = glCreateProgram();
	glAttachShader(shaderProgram0, vertexShaderID);
	glAttachShader(shaderProgram0, fragmentShaderID0);
	glLinkProgram(shaderProgram0);

	GLuint shaderProgram1 = glCreateProgram();
	glAttachShader(shaderProgram1, vertexShaderID);
	glAttachShader(shaderProgram1, fragmentShaderID1);
	glLinkProgram(shaderProgram1);

	GLfloat vertices1[9] = {
		0.0f, 0.0f, 0.0f,
		-0.5f, 0.5f, 0.0f,
		0.5f, 0.5f, 0.0f,
	};

	GLfloat vertices2[9] = {
		0.0f, 0.0f, 0.0f,
		-0.5f, -0.5f, 0.0f,
		0.5f, -0.5f, 0.0f,
	};

	GLuint VAO1;

	GLuint VBO1;
	glGenBuffers(1, &VBO1);
	glBindBuffer(GL_ARRAY_BUFFER, VBO1);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW);

	glGenVertexArrays(1, &VAO1);
	glBindVertexArray(VAO1);
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 3*sizeof(float), NULL);
	glEnableVertexAttribArray(0);

	GLuint VAO2;

	GLuint VBO2;
	glGenBuffers(1, &VBO2);
	glBindBuffer(GL_ARRAY_BUFFER, VBO2);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices2), vertices2, GL_STATIC_DRAW);

	glGenVertexArrays(1, &VAO2);
	glBindVertexArray(VAO2);
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 3 * sizeof(float), NULL);
	glEnableVertexAttribArray(0);

	while (window.isOpen()) {

		sf::Event event;

		while (window.pollEvent(event)) {

			if (event.type == sf::Event::Closed) {
				window.close();
			};
		};

		glClear(GL_COLOR_BUFFER_BIT);
		glClearColor(0.0, 0.0, 0.0, 1.0);
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

		GLint uniform_location0 = glGetUniformLocation(shaderProgram0, "color0");
		glUseProgram(shaderProgram0);
		sf::Time time0 = clock.getElapsedTime();
		float red_value = sin(time0.asSeconds());
		glUniform1f(uniform_location0, red_value);

		glBindVertexArray(VAO1);
		glDrawArrays(GL_TRIANGLES, 0, 3);

		GLint uniform_location1 = glGetUniformLocation(shaderProgram1, "color1");
		glUseProgram(shaderProgram1);
		sf::Time time1 = clock.getElapsedTime();
		float green_value = sin(time1.asSeconds());
		glUniform4f(uniform_location1, 0.0, green_value, 0.0, 1.0);

		glBindVertexArray(VAO2);
		glDrawArrays(GL_TRIANGLES, 0, 3);
		
		glBindVertexArray(0);
		window.display();
	};
};