AfonsoCMSousa/CPP-PPRasteriser
1
0
Fork 0
generated from AfonsoCMSousa/CPP-Template
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed and added some minor color correction

Browse Source
This commit is contained in:
Afonso Clerigo Mendes de Sousa 2025-10-01 22:13:58 +01:00
parent 0c861f6855
commit 9107273a0c
10 changed files with 127 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -68,10 +68,6 @@ else()
target_link_options(${EXECUTABLE_NAME} PRIVATE -fsanitize=address,undefined)
endif()
# -----------------------
# External Dependencies
# -----------------------
# GLFW (if vendored in libraries/)
if(EXISTS ${CMAKE_SOURCE_DIR}/libraries/glfw/CMakeLists.txt)
add_subdirectory(${CMAKE_SOURCE_DIR}/libraries/glfw EXCLUDE_FROM_ALL)

BIN
RASTER
View File

Binary file not shown.

30
shaders/fragment.glsl
View File

@ -76,25 +76,6 @@ vec2 morphingSeed(float t, float interval) {
return mix(seedA, seedB, blend);
}
vec2 morphingDirection(float t, float interval) {
float phase = floor(t / interval);
float blend = fract(t / interval);
// Generate 2 pseudo-random direction vectors
vec2 dirA = normalize(vec2(
sin(phase * 12.9898),
cos(phase * 78.233)
));
vec2 dirB = normalize(vec2(
sin((phase+1.0) * 93.9898),
cos((phase+1.0) * 47.233)
));
// Smooth interpolation between them
blend = smoothstep(0.0, 1.0, blend);
return normalize(mix(dirA, dirB, blend));
}
void main() {
vec2 st = gl_FragCoord.xy / u_resolution.xy; // Normalize coordinates
st.x *= u_resolution.x / u_resolution.y; // Correct aspect ratio
@ -104,7 +85,8 @@ void main() {
st *= 2.05 * u_scale; // Zoom out
vec2 seed = morphingSeed(u_time, 10.0); // 10 second interval
vec2 pos = st + morphingDirection(u_time * 0.2, 15.0); // 15 second interval
vec2 pos = st; // 15 second interval
pos += vec2(0.3, 0.1) * u_time * 0.1;
float pre_noise = perlinNoise((pos) * 1.5); // N = [0..1]
// noise += 0.6 * perlinNoise(pos * 4.0);
@ -120,9 +102,9 @@ void main() {
vec3 color;
if (noise >= 0.9) {
if (noise >= 0.85) {
color = getPaletteColor(u_time * 0.1, noise);
} else if (noise >= 0.76 ) {
} else if (noise >= 0.75 ) {
color = getPaletteColor((u_time * 0.1) + 1.0, noise);
// Estimate gradient (2D normal)
@ -145,7 +127,7 @@ void main() {
float spec = pow(max(dot(normal, lightDir), 0.0), 32.0);
// Combine Fresnel + spec
float gloss = fresnel + 0.5 * spec;
float gloss = fresnel + 0.6 * spec;
// Stronger at edges (transition zone of blob)
float edge = smoothstep(0.8, 0.9, noise) * (1.0 - smoothstep(0.9, 1.0, noise));
@ -157,5 +139,7 @@ void main() {
color = vec3(0.0);
}
// Denoise edges -> "Insane look-alike effect"
color += mix(color, vec3(0.0), smoothstep(0.0, 0.02, abs(noise - 0.9)));
FragColor = vec4(color, 1.0);
}

0
source/compute.cpp
View File

0
source/compute.h
View File

94
source/main.cpp
View File

@ -1,3 +1,9 @@
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
// glad and GLFW
#include <glad/glad.h>
#include <GLFW/glfw3.h>
@ -7,11 +13,8 @@
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
// HPP files
#include "shader.h"
#define VERTEX_FILE "./shaders/vertex.glsl"
#define FRAGMENT_FILE "./shaders/fragment.glsl"
@ -20,85 +23,7 @@
const float SCR_WIDTH = 1200.0f;
const float SCR_HEIGHT = 1200.0f;
// Shader loader helper
std::string loadShaderSource(const std::string& filepath) {
std::ifstream file(filepath);
if (!file.is_open()) {
std::cerr << "Failed to open shader file: " << filepath << std::endl;
return "";
}
std::stringstream buffer;
std::cout << "Loaded " << filepath << " successfully!\n";
buffer << file.rdbuf();
return buffer.str();
}
GLuint compileShader(GLenum type, const std::string& source) {
GLuint shader = glCreateShader(type);
const char* src = source.c_str();
glShaderSource(shader, 1, &src, nullptr);
glCompileShader(shader);
int success;
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success) {
char infoLog[512];
glGetShaderInfoLog(shader, 512, nullptr, infoLog);
std::cerr << "Shader compilation failed:\n" << infoLog << std::endl;
exit(10);
}
return shader;
}
GLuint createShaderProgram(const std::string& vertexPath, const std::string& fragmentPath) {
std::string vertexSrc = loadShaderSource(vertexPath);
std::string fragmentSrc = loadShaderSource(fragmentPath);
GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexSrc);
GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentSrc);
GLuint program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
int success;
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
char infoLog[512];
glGetProgramInfoLog(program, 512, nullptr, infoLog);
std::cerr << "Shader linking failed:\n" << infoLog << std::endl;
exit(11);
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return program;
}
GLuint createComputeProgram(const std::string& computePath) {
std::string computeSrc = loadShaderSource(computePath);
GLuint computeShader = compileShader(GL_COMPUTE_SHADER, computeSrc);
GLuint program = glCreateProgram();
glAttachShader(program, computeShader);
glLinkProgram(program);
int success;
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
char infoLog[512];
glGetProgramInfoLog(program, 512, nullptr, infoLog);
std::cerr << "Compute shader linking failed:\n" << infoLog << std::endl;;
}
glDeleteShader(computeShader);
return program;
}
int main() {
int main(void) {
// Initialize GLFW
if (!glfwInit()) return -1;
@ -205,7 +130,6 @@ int main() {
int frameCount = 0;
float mousePos[2] = {0.0f, 0.0f};
// FPS tracking
double lastTime = glfwGetTime(); // when we last printed FPS
double fps = 0.0;

0
source/renderer.cpp
View File

0
source/renderer.h
View File

80
source/shader.cpp
View File

@ -0,0 +1,80 @@
#include "shader.h"
// Shader loader helper
std::string loadShaderSource(const std::string& filepath) {
std::ifstream file(filepath);
if (!file.is_open()) {
std::cerr << "Failed to open shader file: " << filepath << std::endl;
return "";
}
std::stringstream buffer;
std::cout << "Loaded " << filepath << " successfully!\n";
buffer << file.rdbuf();
return buffer.str();
}
GLuint compileShader(GLenum type, const std::string& source) {
GLuint shader = glCreateShader(type);
const char* src = source.c_str();
glShaderSource(shader, 1, &src, nullptr);
glCompileShader(shader);
int success;
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success) {
char infoLog[512];
glGetShaderInfoLog(shader, 512, nullptr, infoLog);
std::cerr << "Shader compilation failed:\n" << infoLog << std::endl;
exit(10);
}
return shader;
}
GLuint createShaderProgram(const std::string& vertexPath, const std::string& fragmentPath) {
std::string vertexSrc = loadShaderSource(vertexPath);
std::string fragmentSrc = loadShaderSource(fragmentPath);
GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexSrc);
GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentSrc);
GLuint program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
int success;
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
char infoLog[512];
glGetProgramInfoLog(program, 512, nullptr, infoLog);
std::cerr << "Shader linking failed:\n" << infoLog << std::endl;
exit(11);
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return program;
}
/* GLuint createComputeProgram(const std::string& computePath) {
std::string computeSrc = loadShaderSource(computePath);
GLuint computeShader = compileShader(GL_COMPUTE_SHADER, computeSrc);
GLuint program = glCreateProgram();
glAttachShader(program, computeShader);
glLinkProgram(program);
int success;
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
char infoLog[512];
glGetProgramInfoLog(program, 512, nullptr, infoLog);
std::cerr << "Compute shader linking failed:\n" << infoLog << std::endl;;
}
glDeleteShader(computeShader);
return program;
} */

31
source/shader.h
View File

@ -0,0 +1,31 @@
#ifndef SHADER_HPP
#define SHADER_HPP
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <GLFW/glfw3.h>
// Shader loader helper
std::string loadShaderSource(const std::string& filepath);
// Compile a shader of given type from source code
GLuint compileShader(GLenum type, const std::string& source);
// Create a shader program from vertex and fragment shader file paths
GLuint createShaderProgram(const std::string& vertexPath, const std::string& fragmentPath);
// Create a compute shader program from compute shader file path
GLuint createComputeProgram(const std::string& computePath);
#endif // SHADER_HPP