Raymarching

Math as a Creator's Tool

Materiály na stiahnutie / Матеріали для завантаження:

Download PowerPoint (.pptx)
⚙️ Setup Environment (LWJGL)

🛠️ Praktická úloha: Šablóna projektu

Skopírujte tento kód do vášho IDE (súbor RaymarchingTemplate.java). Ide o základnú kostru, ktorá otvára okno a pripravuje prostredie pre písanie shaderov. Počas cvičenia spoločne od nuly naprogramujeme funkciu map a algoritmus raymarch.

RaymarchingTemplate.java
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.opengl.GL;

import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.opengl.GL33C.*;
import static org.lwjgl.system.MemoryUtil.NULL;

public class PracticeTask {

    private long window;
    private int program;
    private int vao;

    private int width = 1000;
    private int height = 800;

    public static void main(String[] args) {
        new PracticeTask().run();
    }

    public void run() {
        initWindow();
        initOpenGL();
        loop();
        cleanup();
    }

    private void initWindow() {
        GLFWErrorCallback.createPrint(System.err).set();
        if (!glfwInit()) throw new IllegalStateException("Nepodarilo sa inicializovať GLFW");

        glfwDefaultWindowHints();
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);

        window = glfwCreateWindow(width, height, "Raymarching Workshop - Start", NULL, NULL);
        if (window == NULL) throw new RuntimeException("Nepodarilo sa vytvoriť okno");

        glfwSetFramebufferSizeCallback(window, (w, nw, nh) -> {
            width = nw; height = nh;
            glViewport(0, 0, width, height);
        });

        glfwMakeContextCurrent(window);
        glfwSwapInterval(1);
        glfwShowWindow(window);
    }

    private void initOpenGL() {
        GL.createCapabilities();
        vao = glGenVertexArrays();
        glBindVertexArray(vao);
        program = createShaderProgram(VERTEX_SHADER, FRAGMENT_SHADER);
    }

    private void loop() {
        while (!glfwWindowShouldClose(window)) {
            glClear(GL_COLOR_BUFFER_BIT);
            glUseProgram(program);

            // Odosielame čas a rozlíšenie do shaderu
            glUniform1f(glGetUniformLocation(program, "uTime"), (float) glfwGetTime());
            glUniform2f(glGetUniformLocation(program, "uResolution"), (float) width, (float) height);

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

            glfwSwapBuffers(window);
            glfwPollEvents();
        }
    }

    private void cleanup() {
        glDeleteProgram(program);
        glDeleteVertexArrays(vao);
        glfwDestroyWindow(window);
        glfwTerminate();
    }

    private int createShaderProgram(String v, String f) {
        int vs = compileShader(GL_VERTEX_SHADER, v);
        int fs = compileShader(GL_FRAGMENT_SHADER, f);
        int p = glCreateProgram();
        glAttachShader(p, vs); glAttachShader(p, fs);
        glLinkProgram(p);
        return p;
    }

    private int compileShader(int type, String src) {
        int s = glCreateShader(type);
        glShaderSource(s, src);
        glCompileShader(s);
        // Kontrola chýb pri kompilácii
        if (glGetShaderi(s, GL_COMPILE_STATUS) == GL_FALSE) {
            System.err.println("Chyba shaderu: " + glGetShaderInfoLog(s));
        }
        return s;
    }

    // Vertex shader vytvorí jeden veľký trojuholník cez celú obrazovku
    private static final String VERTEX_SHADER = """
        #version 330 core
        void main() {
            vec2 pos[3] = vec2[](vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
            gl_Position = vec4(pos[gl_VertexID], 0.0, 1.0);
        }
        """;

    private static final String FRAGMENT_SHADER = """
            #version 330 core
            
            out vec4 fragColor;
            
            uniform float uTime;
            uniform vec2 uResolution;
            
            const int MAX_STEPS = 100;
            const float MAX_DIST = 100.0;
            const float EPSILON = 0.001;
            
            // 1. Sem pridáme funkciu smin (plynulé minimum)
            
            // 2. Sem pridáme SDF primitíva (gule)
            
            // 3. Sem pridáme funkciu map (popis scény)
            float map(vec3 p) {
                return length(p) - 1.0; // Dočasná guľa v strede
            }
            
            // 4. Sem napíšeme algoritmus Raymarching
            float raymarch(vec3 ro, vec3 rd) {
                float t = 0.0;
                for(int i = 0; i < MAX_STEPS; i++) {
                    vec3 p = ro + rd * t;
                    float d = map(p);
                    if(d < EPSILON) return t;
                    if(t > MAX_DIST) break;
                    t += d;
                }
                return -1.0;
            }
            
            // 5. Sem pridáme výpočet normál
            
            void main() {
                // UV súradnice (-1 až 1, s ohľadom na proporcie)
                vec2 uv = (gl_FragCoord.xy * 2.0 - uResolution.xy) / uResolution.y;
                
                // Nastavenie kamery
                vec3 ro = vec3(0.0, 0.0, -5.0); // Pozícia kamery
                vec3 rd = normalize(vec3(uv, 1.0)); // Smer lúča
                
                // Volanie Raymarchingu
                float t = raymarch(ro, rd);
                
                // Základná farba (pozadie)
                vec3 color = vec3(0.1, 0.1, 0.12);
                
                if(t > 0.0) {
                    // Farba pri zásahu (zatiaľ biela)
                    color = vec3(1.0);
                }
                
                
                fragColor = vec4(color, 1.0);
            }
        """;
}