resize viewport

.vscode/compile_commands.json

@@ -0,0 +1,16 @@
+[
+{
+  "directory": "/home/simon/Programmation/GPUCompute",
+  "arguments": ["/usr/bin/g++", "-c", "-m64", "-isystem", "/usr/include/X11/dri", "-isystem", "/home/simon/.xmake/packages/g/glad/v0.1.36/9e3539cb78a3425b96246554411a0b79/include", "-isystem", "/home/simon/.xmake/packages/g/glm/1.0.2/f8fba32531124eb38c4833bdc558de88/include", "-isystem", "/home/simon/.xmake/packages/s/stb/2025.03.14/67005fc11486400896028eb775a57270/include", "-isystem", "/home/simon/.xmake/packages/s/stb/2025.03.14/67005fc11486400896028eb775a57270/include/stb", "-o", "build/.objs/App/linux/x86_64/release/src/Shader.cpp.o", "src/Shader.cpp"],
+  "file": "src/Shader.cpp"
+},
+{
+  "directory": "/home/simon/Programmation/GPUCompute",
+  "arguments": ["/usr/bin/g++", "-c", "-m64", "-isystem", "/usr/include/X11/dri", "-isystem", "/home/simon/.xmake/packages/g/glad/v0.1.36/9e3539cb78a3425b96246554411a0b79/include", "-isystem", "/home/simon/.xmake/packages/g/glm/1.0.2/f8fba32531124eb38c4833bdc558de88/include", "-isystem", "/home/simon/.xmake/packages/s/stb/2025.03.14/67005fc11486400896028eb775a57270/include", "-isystem", "/home/simon/.xmake/packages/s/stb/2025.03.14/67005fc11486400896028eb775a57270/include/stb", "-o", "build/.objs/App/linux/x86_64/release/src/Renderer.cpp.o", "src/Renderer.cpp"],
+  "file": "src/Renderer.cpp"
+},
+{
+  "directory": "/home/simon/Programmation/GPUCompute",
+  "arguments": ["/usr/bin/g++", "-c", "-m64", "-isystem", "/usr/include/X11/dri", "-isystem", "/home/simon/.xmake/packages/g/glad/v0.1.36/9e3539cb78a3425b96246554411a0b79/include", "-isystem", "/home/simon/.xmake/packages/g/glm/1.0.2/f8fba32531124eb38c4833bdc558de88/include", "-isystem", "/home/simon/.xmake/packages/s/stb/2025.03.14/67005fc11486400896028eb775a57270/include", "-isystem", "/home/simon/.xmake/packages/s/stb/2025.03.14/67005fc11486400896028eb775a57270/include/stb", "-o", "build/.objs/App/linux/x86_64/release/src/Main.cpp.o", "src/Main.cpp"],
+  "file": "src/Main.cpp"
+}]

README.md

@@ -1,5 +1,5 @@
-# Real Time Fractal
+# GPU Compute
-Generate random fractals in 3D using chaos game.
+Simple app to run compute shaders using OpenGL.
 
 ## Building
 Just run xmake and build. Here's an example:

Shaders/Vertex.glsl

@@ -1,11 +1,15 @@
 #version 460 core
 
-layout(location = 0) uniform mat4 viewMatrix;
+layout(std430, binding = 3) buffer layoutName
-layout(location = 1) uniform mat4 projectionMatrix;
+{
+    float data_SSBO[];
+};
 
-layout(location = 0) in vec3 position;
+vec3 unpack(uint index) {
+	return vec3(data_SSBO[index * 3], data_SSBO[index * 3 + 1], data_SSBO[index * 3 + 2]);
+}
 
 void main()
 {
-	gl_Position = projectionMatrix * viewMatrix * vec4(position, 1.0);
+	gl_Position = vec4(unpack(gl_InstanceID), 1.0);
 }

src/Main.cpp

@@ -7,18 +7,12 @@
 #include "Shader.h"
 
 #include <chrono>
-#include <random>
 
 constexpr int WORK_GROUP_SIZE = 64;
-constexpr int PARTICLE_COUNT = WORK_GROUP_SIZE * 15625;
+constexpr int PARTICLE_COUNT = WORK_GROUP_SIZE * 10000;
 
 constexpr int SWAP_INTERVAL = 1;
 
-constexpr int TRANSFORMATION_COUNT = 3;
-
-constexpr float ANIMATION_TIME = 2;
-constexpr float ANIMATION_STILL_TIME = .5f;
-
 class Timer {
   public:
 	Timer() {
@@ -46,110 +40,10 @@ static const std::filesystem::path s_ComputeShaderPath = "Shaders/Compute.glsl";
 static const std::filesystem::path s_VertexShaderPath = "Shaders/Vertex.glsl";
 static const std::filesystem::path s_FragmentShaderPath = "Shaders/Fragment.glsl";
 
-static std::random_device s_RandomDevice;
-static std::mt19937 s_Generator(s_RandomDevice());
-static std::uniform_real_distribution<float> s_Distrib(0, 1);
-
 static void ErrorCallback(int error, const char* description) {
 	std::cerr << "Error: " << description << std::endl;
 }
 
-static void ApplyTransforms(const std::vector<glm::mat4>& transformations) {
-	glUseProgram(s_ComputeShader);
-	glUniformMatrix4fv(1, transformations.size(), false, glm::value_ptr(transformations[0]));
-}
-
-struct Transform {
-	float m_ScaleX;
-	float m_ScaleY;
-	float m_ScaleZ;
-
-	float m_RotationX;
-	float m_RotationY;
-	float m_RotationZ;
-
-	float m_ShearXY;
-	float m_ShearXZ;
-	float m_ShearYX;
-	float m_ShearYZ;
-	float m_ShearZX;
-	float m_ShearZY;
-
-	float m_TranslateX;
-	float m_TranslateY;
-	float m_TranslateZ;
-
-	glm::mat4 ToMatrix() {
-		auto scale = glm::scale(glm::mat4(1), {m_ScaleX, m_ScaleY, m_ScaleZ});
-		auto rotateX = glm::rotate(scale, m_RotationX, {1, 0, 0});
-		auto rotateY = glm::rotate(rotateX, m_RotationY, {0, 1, 0});
-		auto rotateZ = glm::rotate(rotateY, m_RotationZ, {0, 0, 1});
-		auto shear = glm::shear(rotateZ, {0, 0, 0}, {m_ShearXY, m_ShearXZ}, {m_ShearYX, m_ShearYZ}, {m_ShearZX, m_ShearZY});
-		auto translate = glm::translate(rotateZ, {m_TranslateX, m_TranslateY, m_TranslateZ});
-
-		return translate;
-	}
-
-	Transform Blend(const Transform& other, const std::function<float(float, float, float)>& a_Lerp, float dt) {
-		return {
-			a_Lerp(m_ScaleX, other.m_ScaleX, dt),
-			a_Lerp(m_ScaleY, other.m_ScaleY, dt),
-			a_Lerp(m_ScaleZ, other.m_ScaleZ, dt),
-			a_Lerp(m_RotationX, other.m_RotationX, dt),
-			a_Lerp(m_RotationY, other.m_RotationY, dt),
-			a_Lerp(m_RotationZ, other.m_RotationZ, dt),
-			a_Lerp(m_ShearXY, other.m_ShearXY, dt),
-			a_Lerp(m_ShearXZ, other.m_ShearXZ, dt),
-			a_Lerp(m_ShearYX, other.m_ShearYX, dt),
-			a_Lerp(m_ShearYZ, other.m_ShearYZ, dt),
-			a_Lerp(m_ShearZX, other.m_ShearZX, dt),
-			a_Lerp(m_ShearZY, other.m_ShearZY, dt),
-			a_Lerp(m_TranslateX, other.m_TranslateX, dt),
-			a_Lerp(m_TranslateY, other.m_TranslateY, dt),
-			a_Lerp(m_TranslateZ, other.m_TranslateZ, dt),
-		};
-	}
-};
-
-static std::vector<Transform> s_T1, s_T2;
-
-static std::vector<Transform> GenRandomFractal() {
-	// scale, rotation, shear, translation
-
-	std::vector<Transform> transforms(TRANSFORMATION_COUNT);
-
-	for (std::size_t i = 0; i < transforms.size(); i++) {
-		Transform transform;
-		transform.m_ScaleX = s_Distrib(s_Generator) * 0.4 + 0.4;
-		transform.m_ScaleY = s_Distrib(s_Generator) * 0.4 + 0.4;
-		transform.m_ScaleZ = s_Distrib(s_Generator) * 0.4 + 0.4;
-
-		transform.m_RotationX = s_Distrib(s_Generator) * 2 * 3.14;
-		transform.m_RotationY = s_Distrib(s_Generator) * 2 * 3.14;
-		transform.m_RotationZ = s_Distrib(s_Generator) * 2 * 3.14;
-
-		transform.m_ShearXY = s_Distrib(s_Generator) * 0.2f - 0.1f;
-		transform.m_ShearXZ = s_Distrib(s_Generator) * 0.2f - 0.1f;
-		transform.m_ShearYX = s_Distrib(s_Generator) * 0.2f - 0.1f;
-		transform.m_ShearYZ = s_Distrib(s_Generator) * 0.2f - 0.1f;
-		transform.m_ShearZX = s_Distrib(s_Generator) * 0.2f - 0.1f;
-		transform.m_ShearZY = s_Distrib(s_Generator) * 0.2f - 0.1f;
-
-		transform.m_TranslateX = s_Distrib(s_Generator) * 1.2f - 0.6f;
-		transform.m_TranslateY = s_Distrib(s_Generator) * 1.2f - 0.6f;
-		transform.m_TranslateZ = s_Distrib(s_Generator) * 1.2f - 0.6f;
-
-		transforms[i] = transform;
-	}
-
-	return transforms;
-}
-
-static void GenNewFractal() {
-	std::swap(s_T1, s_T2);
-	s_T2 = GenRandomFractal();
-}
-
 static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods) {
 	if (action != GLFW_PRESS)
 		return;
@@ -161,47 +55,34 @@ static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, i
 		s_ComputeShader = ReloadComputeShader(s_ComputeShader, s_ComputeShaderPath);
 		s_GraphicsShader = ReloadGraphicsShader(s_GraphicsShader, s_VertexShaderPath, s_FragmentShaderPath);
 		glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float) * PARTICLE_COUNT * 3, nullptr, GL_DYNAMIC_COPY);
-		GenNewFractal();
-	}
-
-	if (key == GLFW_KEY_T) {
-		GenNewFractal();
 	}
 }
 
-
+static GLuint CreateDummyVAO() {
-static std::tuple<GLuint, GLuint> CreateVAO() {
 	GLuint vertexArray;
 	glCreateVertexArrays(1, &vertexArray);
 
 	GLuint vertexBuffer;
 	glCreateBuffers(1, &vertexBuffer);
 
-	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
+	// Buffer with just one point
-	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * PARTICLE_COUNT * 3, nullptr, GL_DYNAMIC_DRAW);
+	float vertices[] = {0.0f, 0.0f, 0.0f};
+	glNamedBufferData(vertexBuffer, sizeof(vertices), vertices, GL_STATIC_DRAW);
 	glVertexArrayVertexBuffer(vertexArray, 0, vertexBuffer, 0, sizeof(float) * 3);
 	glEnableVertexArrayAttrib(vertexArray, 0);
 	glVertexArrayAttribFormat(vertexArray, 0, 3, GL_FLOAT, GL_FALSE, 0);
 	glVertexArrayAttribBinding(vertexArray, 0, 0);
 
-	return {vertexArray, vertexBuffer};
+	return vertexArray;
 }
 
-static std::vector<glm::mat4> GetTransformMatrixBlended(float dt) {
+static void CreateGpuBuffer() {
-	std::vector<glm::mat4> result(TRANSFORMATION_COUNT);
+	GLuint ssbo;
-
+	glGenBuffers(1, &ssbo);
-	constexpr auto lerp = [](float x, float y, float t) { return x * (1 - t) + y * t; };
+	glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
-
+	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, ssbo);
-	constexpr auto eased = [lerp](float x, float y, float t) { return lerp(x, y, -(std::cos(3.14 * t) - 1.0f) / 2.0f); };
+	glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float) * 3 * PARTICLE_COUNT, nullptr,
-
+		GL_DYNAMIC_COPY);  // sizeof(data) only works for statically sized C/C++ arrays.
-	float blendFactor = std::min(ANIMATION_TIME, dt) / ANIMATION_TIME;
-
-	for (std::size_t i = 0; i < result.size(); i++) {
-		auto blended = s_T1[i].Blend(s_T2[i], eased, blendFactor);
-		result[i] = blended.ToMatrix();
-	}
-
-	return result;
 }
 
 static GLFWwindow* InitWindow() {
@@ -240,13 +121,6 @@ static GLFWwindow* InitWindow() {
 		return nullptr;
 	}
 
-	auto viewMatrix = glm::lookAt(glm::vec3{1, 1.5, 1.5}, {0, 0, 0}, {0, 1, 0});
-	auto projectionMatrix = glm::perspective(70.0f, 2.0f, 0.01f, 10.0f);
-
-	glUseProgram(s_GraphicsShader);
-	glUniformMatrix4fv(0, 1, false, glm::value_ptr(viewMatrix));
-	glUniformMatrix4fv(1, 1, false, glm::value_ptr(projectionMatrix));
-
 	return window;
 }
 
@@ -255,25 +129,42 @@ int main() {
 	if (!window)
 		return -1;
 
-	auto [vertexArray, vertexBuffer] = CreateVAO();
+	auto vertexArray = CreateDummyVAO();
+
+	CreateGpuBuffer();
 
 	float lastTime = (float)glfwGetTime();
 
 	int fps = 0;
 	float secondsTimer = 0.0f;
-	float animationTimer = 0.0f;
-
-	// ApplyTransforms(SIERPINSKI_TRIANGLE);
-	s_T1 = GenRandomFractal();
-	s_T2 = GenRandomFractal();
-
-	glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
-
-	glBindBuffer(GL_SHADER_STORAGE_BUFFER, vertexBuffer);
-	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, vertexBuffer);
 
 	glBindVertexArray(vertexArray);
 
+	std::vector<glm::mat4> transformations = {
+		{
+			0.5f, 0.0f, 0.0f, 0.0f,
+			0.0f, 0.5f, 0.0f, 0.36f,
+			0.0f, 0.0f, 0.0f, 0.0f,
+			0.0f, 0.0f, 0.0f, 1.0f,
+		},
+		{
+			0.5f, 0.0f, 0.0f, -0.5f,
+			0.0f, 0.5f, 0.0f, -0.5f,
+			0.0f, 0.0f, 0.0f, 0.0f,
+			0.0f, 0.0f, 0.0f, 1.0f,
+		},
+		{
+			0.5f, 0.0f, 0.0f, 0.5f,
+			0.0f, 0.5f, 0.0f, -0.5f,
+			0.0f, 0.0f, 0.0f, 0.0f,
+			0.0f, 0.0f, 0.0f, 1.0f,
+		},
+	};
+
+	glUseProgram(s_ComputeShader);
+	glUniformMatrix4fv(1, transformations.size(), true, glm::value_ptr(transformations[0]));
+
+
 	while (!glfwWindowShouldClose(window)) {
 		// ScopedTimer timer("Main Loop");
 
@@ -282,7 +173,6 @@ int main() {
 		lastTime = currentTime;
 
 		secondsTimer += dt;
-		animationTimer += dt;
 		if (secondsTimer >= 1.0f) {
 			std::string title = "FPS : " + std::to_string(fps);
 			glfwSetWindowTitle(window, title.c_str());
@@ -291,17 +181,8 @@ int main() {
 			fps = 0;
 		}
 
-		if (animationTimer >= ANIMATION_TIME + ANIMATION_STILL_TIME) {
-			animationTimer = 0;
-			GenNewFractal();
-		}
-
 		// Compute
 		glUseProgram(s_ComputeShader);
-
-		auto matricies = GetTransformMatrixBlended(animationTimer);
-		glUniformMatrix4fv(1, matricies.size(), false, glm::value_ptr(matricies[0]));
-
 		glDispatchCompute(PARTICLE_COUNT / WORK_GROUP_SIZE, 1, 1);
 
 		// Ensure all writes to the image are complete
@@ -310,12 +191,13 @@ int main() {
 		// Graphics
 		glUseProgram(s_GraphicsShader);
 
-		glDrawArrays(GL_POINTS, 0, PARTICLE_COUNT);
+		glDrawArraysInstanced(GL_POINTS, 0, 1, PARTICLE_COUNT);
 
 		glfwSwapBuffers(window);
 		glfwPollEvents();
 
 		glClear(GL_COLOR_BUFFER_BIT);
+		glClearColor(0, 0, 0, 1);
 
 		int width, height;
 		glfwGetWindowSize(window, &width, &height);
@@ -330,6 +212,7 @@ int main() {
 		// 	std::cout << "\t" << positions[i * 3] << " " << positions[i * 3 + 1] << " " << positions[i * 3 + 2] << "\n";
 		// }
 		
+
 		fps++;
 	}
 

xmake.lua

@@ -1,5 +1,3 @@
-add_rules("mode.debug", "mode.release")
-
 add_requires("glfw", "glad", "glm", "stb")
 
 target("App")