remove memory fetch of vertex shader

Reviewed-on: #1
Co-authored-by: Persson-dev <sim16.prib@gmail.com>
Co-committed-by: Persson-dev <sim16.prib@gmail.com>

.vscode/compile_commands.json

@@ -1,16 +0,0 @@
-[
-{
-  "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 @@
-# GPU Compute
+# Real Time Fractal
-Simple app to run compute shaders using OpenGL.
+Generate random fractals in 3D using chaos game.
 
 ## Building
 Just run xmake and build. Here's an example:

Shaders/Fragment.glsl

@@ -4,5 +4,5 @@ layout (location = 0) out vec4 o_Color;
 
 void main()
 {
-    o_Color = vec4(1, 1, 1, 1); 
+    o_Color = vec4(1, 1, 1, 1);
 }

Shaders/Vertex.glsl

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

src/Main.cpp

@@ -7,12 +7,18 @@
 #include "Shader.h"
 
 #include <chrono>
+#include <random>
 
 constexpr int WORK_GROUP_SIZE = 64;
-constexpr int PARTICLE_COUNT = WORK_GROUP_SIZE * 10000;
+constexpr int PARTICLE_COUNT = WORK_GROUP_SIZE * 15625;
 
 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() {
@@ -40,10 +46,110 @@ 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;
@@ -55,34 +161,47 @@ 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);
 
-	// Buffer with just one point
+	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
-	float vertices[] = {0.0f, 0.0f, 0.0f};
+	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * PARTICLE_COUNT * 3, nullptr, GL_DYNAMIC_DRAW);
-	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;
+	return {vertexArray, vertexBuffer};
 }
 
-static void CreateGpuBuffer() {
+static std::vector<glm::mat4> GetTransformMatrixBlended(float dt) {
-	GLuint ssbo;
+	std::vector<glm::mat4> result(TRANSFORMATION_COUNT);
-	glGenBuffers(1, &ssbo);
+
-	glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
+	constexpr auto lerp = [](float x, float y, float t) { return x * (1 - t) + y * t; };
-	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, ssbo);
+
-	glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float) * 3 * PARTICLE_COUNT, nullptr,
+	constexpr auto eased = [lerp](float x, float y, float t) { return lerp(x, y, -(std::cos(3.14 * t) - 1.0f) / 2.0f); };
-		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() {
@@ -121,6 +240,13 @@ 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;
 }
 
@@ -129,42 +255,25 @@ int main() {
 	if (!window)
 		return -1;
 
-	auto vertexArray = CreateDummyVAO();
+	auto [vertexArray, vertexBuffer] = CreateVAO();
-
-	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");
 
@@ -173,6 +282,7 @@ 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());
@@ -181,23 +291,31 @@ int main() {
 			fps = 0;
 		}
 
+		if (animationTimer >= ANIMATION_TIME + ANIMATION_STILL_TIME) {
+			animationTimer = 0;
+			GenNewFractal();
+		}
+
 		// Compute
 		glUseProgram(s_ComputeShader);
-		glDispatchCompute(PARTICLE_COUNT / WORK_GROUP_SIZE, 1, 1);
 
+		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
 		glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
-
+		
 		// Graphics
 		glUseProgram(s_GraphicsShader);
 
-		glDrawArraysInstanced(GL_POINTS, 0, 1, PARTICLE_COUNT);
+		glDrawArrays(GL_POINTS, 0, PARTICLE_COUNT);
 
 		glfwSwapBuffers(window);
 		glfwPollEvents();
 
 		glClear(GL_COLOR_BUFFER_BIT);
-		glClearColor(0, 0, 0, 1);
 
 		int width, height;
 		glfwGetWindowSize(window, &width, &height);
@@ -211,7 +329,6 @@ int main() {
 		// {
 		// 	std::cout << "\t" << positions[i * 3] << " " << positions[i * 3 + 1] << " " << positions[i * 3 + 2] << "\n";
 		// }
-		
 
 		fps++;
 	}

xmake.lua

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