style: fomatted to LLVM

FullScreenQuad.hpp

@@ -1,33 +1,35 @@
 #include <GL/glew.h>
 
-
 class FullScreenQuad {
-private:
+  private:
     unsigned int vao;
-public:
+
+  public:
     FullScreenQuad();
-    int getVAO() { return vao;}
+    int getVAO() { return vao; }
 };
 
-FullScreenQuad::FullScreenQuad(){
+FullScreenQuad::FullScreenQuad() {
-    float quadVertices[] = { // vertex attributes for a quad that fills the entire screen in Normalized Device Coordinates.
+    float quadVertices[] = {// vertex attributes for a quad that fills the
-        // positions   // texCoords
+                            // entire screen in Normalized Device Coordinates.
-        -1.0f,  1.0f,  0.0f, 1.0f,
+                            // positions   // texCoords
-        -1.0f, -1.0f,  0.0f, 0.0f,
+                            -1.0f, 1.0f, 0.0f, 1.0f,  -1.0f, -1.0f,
-         1.0f, -1.0f,  1.0f, 0.0f,
+                            0.0f,  0.0f, 1.0f, -1.0f, 1.0f,  0.0f,
+
+                            -1.0f, 1.0f, 0.0f, 1.0f,  1.0f,  -1.0f,
+                            1.0f,  0.0f, 1.0f, 1.0f,  1.0f,  1.0f};
 
-        -1.0f,  1.0f,  0.0f, 1.0f,
-         1.0f, -1.0f,  1.0f, 0.0f,
-         1.0f,  1.0f,  1.0f, 1.0f
-    };
     unsigned int vbo;
     glGenVertexArrays(1, &vao);
     glGenBuffers(1, &vbo);
     glBindVertexArray(vao);
     glBindBuffer(GL_ARRAY_BUFFER, vbo);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices,
+                 GL_STATIC_DRAW);
     glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float),
+                          (void *)0);
     glEnableVertexAttribArray(1);
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float)));
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float),
+                          (void *)(2 * sizeof(float)));
 }

main.cpp

@@ -1,29 +1,26 @@
+#include "FullScreenQuad.hpp"
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <cstdio>
-#include "FullScreenQuad.hpp"
-
 
 const char *vertexShaderSource =
 #include "fsq.vs"
-;
+    ;
 
 const char *fragmentShaderSource =
 #include "sdf.fs"
-;
+    ;
 
 /*void framebuffer_size_callback(GLFWwindow* window, int width, int height)
 {
     glViewport(0, 0, wdth, height);
 }*/
 
-void processInput(GLFWwindow *window)
+void processInput(GLFWwindow *window) {
-{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
-    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
         glfwSetWindowShouldClose(window, true);
 }
 
-
 unsigned int compVertexShader() {
     unsigned int vertexShader;
     vertexShader = glCreateShader(GL_VERTEX_SHADER);
@@ -38,20 +35,19 @@ unsigned int compFragmentShader() {
     glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
     glCompileShader(fragmentShader);
 
+    // Print shader comp error
     GLint isCompiled = 0;
     glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &isCompiled);
-    if(isCompiled == GL_FALSE)
+    if (isCompiled == GL_FALSE) {
-    {
         GLint maxLength = 0;
         glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &maxLength);
 
         // The maxLength includes the NULL character
-        //std::vector<GLchar> errorLog(maxLength);
+        // std::vector<GLchar> errorLog(maxLength);
-        char * errorLog = new char[maxLength]();
+        char *errorLog = new char[maxLength]();
         glGetShaderInfoLog(fragmentShader, maxLength, &maxLength, errorLog);
 
-        printf("\nFrag Log: %s\n",errorLog);
+        printf("\nFrag Log: %s\n", errorLog);
-
     }
 
     return fragmentShader;
@@ -72,23 +68,20 @@ unsigned int compShader() {
     return shaderProgram;
 }
 
-
+void framebuffer_size_callback(GLFWwindow *window, int width, int height) {
-void framebuffer_size_callback(GLFWwindow* window, int width, int height)
-{
     glViewport(0, 0, width, height);
 }
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
 
-    GLFWwindow* window;
+    GLFWwindow *window;
 
     if (!glfwInit())
         return -1;
 
     window = glfwCreateWindow(800, 600, "Hello World", NULL, NULL);
 
-    if (!window)
+    if (!window) {
-    {
         glfwTerminate();
         return -1;
     }
@@ -101,26 +94,21 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-
     glViewport(0, 0, 800, 600);
 
-
     glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
 
     unsigned int shaderProgramm = compShader();
 
     FullScreenQuad fsq{};
 
-    while (!glfwWindowShouldClose(window))
+    while (!glfwWindowShouldClose(window)) {
-    {
         processInput(window);
         /* Render here */
 
-
         glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT);
 
-	
         glUseProgram(shaderProgramm);
 
         glDrawArrays(GL_TRIANGLES, 0, 3);
@@ -135,4 +123,3 @@ int main(int argc, char** argv) {
 
     glfwTerminate();
 }
-

sdf.fs

@@ -7,29 +7,70 @@ in vec2 texCoords;
 vec3 center = vec3(0.0f,0.0f,20.0f);
 float radius = 5.0f;
 
-float sphereMin(vec3 pos){
+float planeHeight = -7.0f;
-    return length(pos - center) - radius;
+
+struct Ray {
+    vec3 dir;
+    vec3 pos;
+    float min;
+    float len;
+    vec3 color;
+};
+        
+Ray applyMin(Ray ray) {
+    vec3 off = ray.dir * ray.min;
+    ray.pos = ray.pos + off;
+    ray.len = ray.len +  ray.min;
+    return ray;
+}
+
+
+Ray planeMin(Ray ray){
+    ray.min = ray.pos.y - planeHeight;
+    ray.color = vec3(1.0,1.0,1.0);
+    return applyMin(ray);
+}
+
+Ray sphereMin(Ray ray){
+    ray.min = length(ray.pos - center) - radius;
+    ray.color = vec3(1.0,0.0,0.0);
+    return applyMin(ray);
+}
+
+Ray minFn(Ray ray){
+    Ray sp = sphereMin(ray);
+    Ray pl = planeMin(ray);
+
+    if (sp.min < pl.min){
+        return sp;
+    } else {
+        return pl;
+    }
 }
 
 void main()
 {
-    vec3 ray = vec3(texCoords.x, texCoords.y,2.0f);
+    vec3 dir = vec3(texCoords.x, texCoords.y,2.0f);
-    ray = (ray - 0.5f) * 2;
+    dir = (dir - 0.5f) * 2;
-    vec3 pos = ray;
+    vec3 pos = dir;
-    float min = sphereMin(ray);
+    Ray ray = Ray(pos,normalize(dir),.0,.0,vec3(.0));
+
+
+    ray = minFn(ray);
+
+    while( (ray.min < 100.0f) && (ray.min > 0.1f) ) {
+        //ray.dir = normalize(ray.dir);
+        ray = minFn(ray);
+        //vec3 off = ray.dir * min;
+        //ray.pos = ray.pos + off;
         
-    while( (min < 100.0f) && (min > 0.1f) ) {
-        ray = normalize(ray);
-        ray = ray * min;
-        pos = pos + ray;
-        min = sphereMin(pos);
     }
     
     
-    if(min <= 0.2f){
+    if(ray.min <= 0.2f){
-        FragColor = vec4(texCoords.x, texCoords.y, 0.2f, 1.0f);
+        FragColor = vec4(ray.color, 1.0f);
     } else {
-        FragColor = vec4(0.0f,0.0f,0.0f,1.0f);
+        FragColor = vec4(.0,0.0f,0.0f,1.0f);
     }
 
 }