Upload pixeloe_demo.c

pixeloe_demo.c

@@ -0,0 +1,447 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+// GLEW must be included before GLFW
+#define GLEW_STATIC
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+
+// STB Image for loading images
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+// Shader utilities
+void check_shader_error(GLuint shader, const char* type);
+GLuint load_shader(const char* vertex_path, const char* fragment_path);
+GLuint load_texture(const char* path, int* width, int* height);
+
+// Window and input handling
+void framebuffer_size_callback(GLFWwindow* window, int width, int height);
+void process_input(GLFWwindow* window);
+
+// Settings
+int window_width = 512;
+int window_height = 512;
+
+// PixelOE parameters (adjustable in real-time)
+int pixel_size = 6;
+int thickness = 3;
+float avg_scale = 10.0f;
+float dist_scale = 3.0f;
+bool show_original = false;
+
+int main(int argc, char** argv) {
+    // Check command line arguments
+    printf("=== start checking command arguments === \n");
+    if (argc < 3) {
+        printf("Usage: %s <image_path>\n", argv[0]);
+        return 1;
+    }
+
+    printf("=== checking command arguments success === \n");
+
+    const char* image_path = argv[1];
+    bool show_FPS = argv[2];
+
+    // region Windows Management
+    // ********** windows management **********
+    // not important thing. just for setting up the window
+    
+    // Initialize GLFW
+    if (!glfwInit()) {
+        fprintf(stderr, "Failed to initialize GLFW\n");
+        return -1;
+    }
+    
+    // Configure GLFW
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    
+    // Create window
+    GLFWwindow* window = glfwCreateWindow(window_width, window_height, "PixelOE Demo", NULL, NULL);
+    if (window == NULL) {
+        fprintf(stderr, "Failed to create GLFW window\n");
+        glfwTerminate();
+        return -1;
+    }
+    glfwMakeContextCurrent(window);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+    
+    // Initialize GLEW
+    glewExperimental = GL_TRUE;
+    if (glewInit() != GLEW_OK) {
+        fprintf(stderr, "Failed to initialize GLEW\n");
+        glfwTerminate();
+        return -1;
+    }
+    
+    // Load image texture
+    int image_width, image_height;
+    GLuint texture = load_texture(image_path, &image_width, &image_height);
+    if (texture == 0) {
+        fprintf(stderr, "Failed to load image: %s\n", image_path);
+        glfwTerminate();
+        return -1;
+    }
+    
+    // Set window size based on image dimensions (with reasonable limits)
+    window_width = image_width < 1200 ? image_width : 1200;
+    window_height = image_height < 900 ? image_height : 900;
+    glfwSetWindowSize(window, window_width, window_height);
+
+    // endregion
+    // ********** windows management **********
+    
+    // Load shaders
+    printf("=== start loading shaders === \n");
+
+    GLuint shader_program = load_shader("shader.vert", "shader.frag");
+    if (shader_program == 0) {
+        glfwTerminate();
+        return -1;
+    }
+
+    printf("=== loading shaders success === \n");
+    
+    // Set up quad vertices for rendering
+    // vert list.it will be used in `shader.vert`
+    // send 4 verts to GPU
+    // then just show the texture
+    float vertices[] = {
+        // positions        // texture coords
+        -1.0f,  1.0f, 0.0f, 0.0f, 0.0f,  // top left
+        -1.0f, -1.0f, 0.0f, 0.0f, 1.0f,  // bottom left
+         1.0f, -1.0f, 0.0f, 1.0f, 1.0f,  // bottom right
+         1.0f,  1.0f, 0.0f, 1.0f, 0.0f   // top right
+    };
+    
+    // use verts to draw 2 triangles
+    // fill all quad
+    unsigned int indices[] = {
+        0, 1, 2,  // first triangle
+        0, 2, 3   // second triangle
+    };
+    
+    // Create buffers
+    GLuint VAO, VBO, EBO;
+    glGenVertexArrays(1, &VAO);
+    glGenBuffers(1, &VBO);
+    glGenBuffers(1, &EBO);
+    
+    glBindVertexArray(VAO);
+    
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+    
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+    
+    // Position attribute
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
+    glEnableVertexAttribArray(0);
+    
+    // Texture coordinate attribute
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
+    glEnableVertexAttribArray(1);
+    
+    // Use shader program
+    glUseProgram(shader_program);
+    
+    // Set texture sampler
+    glUniform1i(glGetUniformLocation(shader_program, "inputTexture"), 0);
+    
+    // Print controls
+    printf("\nControls:\n");
+    printf("  Arrow Up/Down: Adjust pixel size (%d)\n", pixel_size);
+    printf("  Arrow Left/Right: Adjust thickness (%d)\n", thickness);
+    printf("  A/Z: Adjust avgScale (%.1f)\n", avg_scale);
+    printf("  S/X: Adjust distScale (%.1f)\n", dist_scale);
+    printf("  O: Toggle original/processed view\n");
+    printf("  ESC: Quit\n\n");
+    
+    // Render loop
+
+    double lastTime = glfwGetTime();
+    int frameCount = 0;
+
+    while (!glfwWindowShouldClose(window)) {
+
+        if (show_FPS == 1)
+        {
+            // calculate FPS
+            double currentTime = glfwGetTime();
+            frameCount++;
+            
+            // refresh FPS every second
+            if (currentTime - lastTime >= 1.0) {
+                // print FPS
+                printf("FPS: %d\n", frameCount);
+                
+                // reset frameCount
+                frameCount = 0;
+                lastTime = currentTime;
+            }
+        }
+        
+        // Process input
+        process_input(window);
+        
+        // Get current frame buffer size
+        glfwGetFramebufferSize(window, &window_width, &window_height);
+        
+        // Clear the screen
+        glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT);
+        
+        // Use shader program
+        glUseProgram(shader_program);
+        
+        // Update uniforms
+        glUniform1i(glGetUniformLocation(shader_program, "pixelSize"), pixel_size);
+        glUniform1i(glGetUniformLocation(shader_program, "thickness"), thickness);
+        glUniform1f(glGetUniformLocation(shader_program, "avgScale"), avg_scale);
+        glUniform1f(glGetUniformLocation(shader_program, "distScale"), dist_scale);
+        glUniform2f(glGetUniformLocation(shader_program, "resolution"), (float)window_width, (float)window_height);
+        glUniform1i(glGetUniformLocation(shader_program, "showOriginal"), show_original);
+        
+        // Bind texture
+        glActiveTexture(GL_TEXTURE0);
+        glBindTexture(GL_TEXTURE_2D, texture);
+        
+        // Draw quad
+        glBindVertexArray(VAO);
+        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+        
+        // Swap buffers and poll events
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+    
+    // Clean up
+    glDeleteVertexArrays(1, &VAO);
+    glDeleteBuffers(1, &VBO);
+    glDeleteBuffers(1, &EBO);
+    glDeleteProgram(shader_program);
+    glDeleteTextures(1, &texture);
+    
+    glfwTerminate();
+    return 0;
+}
+
+void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
+    (void)window; // Avoid unused parameter warning
+    glViewport(0, 0, width, height);
+}
+
+// control functions
+void process_input(GLFWwindow* window) {
+    static bool keys_pressed[512] = {false};
+    
+    // Handle key presses with cooldown
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+    
+    // Adjust pixel size
+    if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS && !keys_pressed[GLFW_KEY_UP]) {
+        pixel_size = (pixel_size < 32) ? pixel_size + 1 : pixel_size;
+        printf("Pixel size: %d\n", pixel_size);
+        keys_pressed[GLFW_KEY_UP] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_UP] = false;
+    
+    if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS && !keys_pressed[GLFW_KEY_DOWN]) {
+        pixel_size = (pixel_size > 1) ? pixel_size - 1 : pixel_size;
+        printf("Pixel size: %d\n", pixel_size);
+        keys_pressed[GLFW_KEY_DOWN] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_DOWN] = false;
+    
+    // Adjust thickness
+    if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS && !keys_pressed[GLFW_KEY_RIGHT]) {
+        thickness = (thickness < 6) ? thickness + 1 : thickness;
+        printf("Thickness: %d\n", thickness);
+        keys_pressed[GLFW_KEY_RIGHT] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_RIGHT] = false;
+    
+    if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS && !keys_pressed[GLFW_KEY_LEFT]) {
+        thickness = (thickness > 0) ? thickness - 1 : thickness;
+        printf("Thickness: %d\n", thickness);
+        keys_pressed[GLFW_KEY_LEFT] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_LEFT] = false;
+    
+    // Adjust avgScale
+    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS && !keys_pressed[GLFW_KEY_A]) {
+        avg_scale += 0.5f;
+        printf("Avg scale: %.1f\n", avg_scale);
+        keys_pressed[GLFW_KEY_A] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_A] = false;
+    
+    if (glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS && !keys_pressed[GLFW_KEY_Z]) {
+        avg_scale -= 0.5f;
+        printf("Avg scale: %.1f\n", avg_scale);
+        keys_pressed[GLFW_KEY_Z] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_Z) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_Z] = false;
+    
+    // Adjust distScale
+    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS && !keys_pressed[GLFW_KEY_S]) {
+        dist_scale += 0.5f;
+        printf("Dist scale: %.1f\n", dist_scale);
+        keys_pressed[GLFW_KEY_S] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_S] = false;
+    
+    if (glfwGetKey(window, GLFW_KEY_X) == GLFW_PRESS && !keys_pressed[GLFW_KEY_X]) {
+        dist_scale -= 0.5f;
+        printf("Dist scale: %.1f\n", dist_scale);
+        keys_pressed[GLFW_KEY_X] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_X) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_X] = false;
+    
+    // Toggle original/processed view
+    if (glfwGetKey(window, GLFW_KEY_O) == GLFW_PRESS && !keys_pressed[GLFW_KEY_O]) {
+        show_original = !show_original;
+        printf("Showing %s\n", show_original ? "original" : "pixelized");
+        keys_pressed[GLFW_KEY_O] = true;
+    }
+    if (glfwGetKey(window, GLFW_KEY_O) == GLFW_RELEASE)
+        keys_pressed[GLFW_KEY_O] = false;
+}
+
+GLuint load_shader(const char* vertex_path, const char* fragment_path) {
+    // Read vertex shader from file
+    FILE* vertex_file = fopen(vertex_path, "r");
+    if (!vertex_file) {
+        fprintf(stderr, "Failed to open vertex shader file: %s\n", vertex_path);
+        return 0;
+    }
+    
+    fseek(vertex_file, 0, SEEK_END);
+    long vertex_size = ftell(vertex_file);
+    fseek(vertex_file, 0, SEEK_SET);
+    
+    char* vertex_source = (char*)malloc(vertex_size + 1);
+    fread(vertex_source, 1, vertex_size, vertex_file);
+    vertex_source[vertex_size] = '\0';
+    fclose(vertex_file);
+    
+    // Read fragment shader from file
+    FILE* fragment_file = fopen(fragment_path, "r");
+    if (!fragment_file) {
+        fprintf(stderr, "Failed to open fragment shader file: %s\n", fragment_path);
+        free(vertex_source);
+        return 0;
+    }
+    
+    fseek(fragment_file, 0, SEEK_END);
+    long fragment_size = ftell(fragment_file);
+    fseek(fragment_file, 0, SEEK_SET);
+    
+    char* fragment_source = (char*)malloc(fragment_size + 1);
+    fread(fragment_source, 1, fragment_size, fragment_file);
+    fragment_source[fragment_size] = '\0';
+    fclose(fragment_file);
+    
+    // Create and compile vertex shader
+    GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertex_shader, 1, (const char**)&vertex_source, NULL);
+    glCompileShader(vertex_shader);
+    check_shader_error(vertex_shader, "VERTEX");
+    
+    // Create and compile fragment shader
+    GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragment_shader, 1, (const char**)&fragment_source, NULL);
+    glCompileShader(fragment_shader);
+    check_shader_error(fragment_shader, "FRAGMENT");
+    
+    // Create and link shader program
+    GLuint program = glCreateProgram();
+    glAttachShader(program, vertex_shader);
+    glAttachShader(program, fragment_shader);
+    glLinkProgram(program);
+    
+    // Check for linking errors
+    GLint success;
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+    if (!success) {
+        char info_log[512];
+        glGetProgramInfoLog(program, 512, NULL, info_log);
+        fprintf(stderr, "Shader program linking failed: %s\n", info_log);
+        return 0;
+    }
+    
+    // Clean up
+    glDeleteShader(vertex_shader);
+    glDeleteShader(fragment_shader);
+    free(vertex_source);
+    free(fragment_source);
+    
+    return program;
+}
+
+void check_shader_error(GLuint shader, const char* type) {
+    GLint success;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+    if (!success) {
+        char info_log[512];
+        glGetShaderInfoLog(shader, 512, NULL, info_log);
+        fprintf(stderr, "%s shader compilation failed: %s\n", type, info_log);
+    }
+}
+
+GLuint load_texture(const char* path, int* width, int* height) {
+    // Generate texture
+    GLuint texture_id;
+    glGenTextures(1, &texture_id);
+    
+    // Load image
+    int channels;
+    unsigned char* data = stbi_load(path, width, height, &channels, 0);
+    if (!data) {
+        fprintf(stderr, "Failed to load image: %s\n", path);
+        return 0;
+    }
+    
+    // Determine format based on number of channels
+    GLenum format;
+    if (channels == 1)
+        format = GL_RED;
+    else if (channels == 3)
+        format = GL_RGB;
+    else if (channels == 4)
+        format = GL_RGBA;
+    else {
+        fprintf(stderr, "Unsupported image format (channels: %d)\n", channels);
+        stbi_image_free(data);
+        return 0;
+    }
+    
+    // Bind and configure texture
+    glBindTexture(GL_TEXTURE_2D, texture_id);
+    glTexImage2D(GL_TEXTURE_2D, 0, format, *width, *height, 0, format, GL_UNSIGNED_BYTE, data);
+    glGenerateMipmap(GL_TEXTURE_2D);
+    
+    // Set texture parameters
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    
+    // Free image data
+    stbi_image_free(data);
+    
+    return texture_id;
+}