Tesselation evaluation

CMakeLists.txt

@@ -39,6 +39,8 @@ file(GLOB_RECURSE EXTERNAL_FILES
 file(GLOB_RECURSE SHADER_FILES
     "shaders/*.frag"
     "shaders/*.vert"
+    "shaders/*.tesc"
+    "shaders/*.tese"
     "shaders/*.geom"
     "shaders/*.comp"
     "shaders/*.glsl"

README.md

@@ -18,3 +18,15 @@ make
 If you have a problem, please send a mail to
 - alexandre.lamure@epita.fr
 - gregoire.angerand@gmail.com
+
+### TODO
+in file :
+- main.cpp
+- ocean_control.tess
+- ocean_evaluation.tess
+- ocean.frag
+- ocean.vert
+
+Look if need for file for tesselation.
+
+separate task to do.

shaders/ifft_horizontal_waves.comp

@@ -0,0 +1,67 @@
+#version 450
+
+layout(local_size_x = 1, local_size_y = 16) in;
+
+layout(binding = 0, rgba16f) uniform image2D waves_real;
+layout(binding = 1, rgba16f) uniform image2D waves_img;
+layout(binding = 2, rgba16f) uniform image2D tmp_real;
+layout(binding = 3, rgba16f) uniform image2D tmp_img;
+
+const float PI = 3.14159265359;
+
+vec2 cmul(vec2 a, vec2 b) {
+    return vec2(a.x*b.x - a.y*b.y, a.x*b.y + a.y*b.x);
+}
+
+void main(){
+    int y = int(gl_GlobalInvocationID.y);
+    int size = imageSize(waves_real).x;
+    if (y >= size)
+        return;
+
+    vec2 Dx[512];
+    vec2 Dy[512];
+    vec2 Dz[512];
+
+    for (int x = 0; x < size; x++) {
+        vec4 r = imageLoad(waves_real, ivec2(x, y));
+        vec4 i = imageLoad(waves_img, ivec2(x, y));
+        Dx[x] = vec2(r.r, i.r);
+        Dy[x] = vec2(r.g, i.g);
+        Dz[x] = vec2(r.b, i.b);
+    }
+
+    for (int s = 1; s <= int(log2(size)); s++) {
+        int m = 1 << s;
+        int m2 = m >> 1;
+        float theta = 2.0 * PI / float(m);
+        for (int k = 0; k < size; k += m) {
+            for (int j = 0; j < m2; j++) {
+                float ang = theta * float(j);
+                vec2 w = vec2(cos(ang), sin(ang));
+                vec2 tx = cmul(w, Dx[k + j + m2]);
+                vec2 ty = cmul(w, Dy[k + j + m2]);
+                vec2 tz = cmul(w, Dz[k + j + m2]);
+                vec2 ux = Dx[k + j];
+                vec2 uy = Dy[k + j];
+                vec2 uz = Dz[k + j];
+                Dx[k + j] = ux + tx;
+                Dy[k + j] = uy + ty;
+                Dz[k + j] = uz + tz;
+                Dx[k + j + m2] = ux - tx;
+                Dy[k + j + m2] = uy - ty;
+                Dz[k + j + m2] = uz - tz;
+            }
+        }
+    }
+
+    for (int x = 0; x < size; x++) {
+        Dx[x] /= float(size);
+        Dy[x] /= float(size);
+        Dz[x] /= float(size);
+        vec3 real_row = vec3(Dx[x].x, Dy[x].x, Dz[x].x);
+        vec3 img_row = vec3(Dx[x].y, Dy[x].y, Dz[x].y);
+        imageStore(tmp_real, ivec2(x, y), vec4(real_row, 1.0));
+        imageStore(tmp_img, ivec2(x, y), vec4(img_row, 1.0)); 
+    } 
+}

shaders/ifft_vertical_waves.comp

@@ -0,0 +1,70 @@
+#version 450
+
+layout(local_size_x = 16, local_size_y = 1) in;
+
+layout(binding = 0, rgba16f) uniform image2D tmp_real;
+layout(binding = 1, rgba16f) uniform image2D tmp_img;
+layout(binding = 2, rgba16f) uniform image2D result_real;
+// layout(binding = 3, rgba16f) uniform image2D result_img;
+
+const float PI = 3.14159265359;
+
+vec2 cmul(vec2 a, vec2 b) {
+    return vec2(a.x*b.x - a.y*b.y, a.x*b.y + a.y*b.x);
+}
+
+void main(){
+    int x = int(gl_GlobalInvocationID.x);
+    int size = imageSize(tmp_real).x;
+    if (x >= size)
+        return;
+
+    vec2 Dx[512];
+    vec2 Dy[512];
+    vec2 Dz[512];
+
+    for (int y = 0; y < size; y++) {
+        vec4 r = imageLoad(tmp_real, ivec2(x, y));
+        vec4 i = imageLoad(tmp_img, ivec2(x, y));
+        Dx[y] = vec2(r.r, i.r);
+        Dy[y] = vec2(r.g, i.g);
+        Dz[y] = vec2(r.b, i.b);
+    }
+
+    for (int s = 1; s <= int(log2(size)); s++) {
+        int m = 1 << s;
+        int m2 = m >> 1;
+        float theta = 2.0 * PI / float(m);
+        for (int k = 0; k < size; k += m) {
+            for (int j = 0; j < m2; j++) {
+                float ang = theta * float(j);
+                vec2 w = vec2(cos(ang), sin(ang));
+                vec2 tx = cmul(w, Dx[k + j + m2]);
+                vec2 ty = cmul(w, Dy[k + j + m2]);
+                vec2 tz = cmul(w, Dz[k + j + m2]);
+                vec2 ux = Dx[k + j];
+                vec2 uy = Dy[k + j];
+                vec2 uz = Dz[k + j];
+                Dx[k + j] = ux + tx;
+                Dy[k + j] = uy + ty;
+                Dz[k + j] = uz + tz;
+                Dx[k + j + m2] = ux - tx;
+                Dy[k + j + m2] = uy - ty;
+                Dz[k + j + m2] = uz - tz;
+            }
+        }
+    }
+
+    for (int y = 0; y < size; y++) {
+        Dx[y] /= float(size);
+        Dy[y] /= float(size);
+        Dz[y] /= float(size);
+
+        // Apply frequency shift: multiply by (-1)^(x+y)
+        float sign = ((x + y) & 1) == 0 ? 1.0 : -1.0;
+        vec3 real_col = vec3(Dx[y].x, Dy[y].x, Dz[y].x) * sign;
+
+        imageStore(result_real, ivec2(x, y), vec4(real_col, 1.0));
+        // imageStore(result_img, ivec2(x, y), vec4(img_col, 1.0));
+    } 
+}

shaders/init_waves.comp

@@ -0,0 +1,83 @@
+#version 450
+
+layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
+
+layout(binding = 0, rgba16f) uniform image2D h0k;
+
+uniform float octave;
+
+const float wind_speed = 100.0;
+const vec2 wind_direction = normalize(vec2(1.0, 1.0));
+const float amplitude = 0.001;
+
+const float PI = 3.14159265359;
+const float G = 9.8; // Gravity (m/s**2)
+
+float phillips_spectrum(vec2 k) {
+    float k_length = length(k);
+    if (k_length < 0.0001) return 0.0;
+
+    float k_length_2 = k_length * k_length;
+    float k_length_4 = k_length_2 * k_length_2;
+
+    float speed_2 = wind_speed * wind_speed;
+    float L = speed_2 / G;
+    float L2 = L * L;
+
+    vec2 k_norm = k / k_length;
+    float k_dot_w = dot(k_norm, wind_direction);
+    float k_dot_w_2 = k_dot_w * k_dot_w;
+
+    if (k_dot_w < 0.0) k_dot_w_2 *= 0.07;
+
+    float l = L* 0.001;
+
+    // Phillips spectrum
+    return amplitude * exp(-1.0 / (k_length_2 * L2)) / k_length_4 * k_dot_w_2 * exp(-k_length_2 * l * l);
+}
+
+uint hash(uint seed) {
+    uint state = seed * 747796405u + 2891336453u;
+    uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+    return (word >> 22u) ^ word;
+}
+
+float random(uint seed) {
+    seed = hash(seed);
+    return float(seed) / 4294967296.0;
+}
+
+vec2 gaussianRandom(uint seed) {
+    float u1 = random(seed);
+    float u2 = random(seed);
+    float r = sqrt(-2.0 * log(u1));
+    float t = 2.0 * PI * u2;
+    return vec2(r * cos(t), r * sin(t));
+}
+
+void main() {
+    ivec2 uv = ivec2(gl_GlobalInvocationID.xy);
+    uint size = imageSize(h0k).x;
+
+    if (uv.x >= size || uv.y >= size)
+        return;
+
+    vec2 x = vec2(uv) - float(size) / 2.0;
+
+    float wave_size = 8192.0 / pow(2.0, octave);
+    vec2 k = 2.0 * PI * x / wave_size;
+
+    vec2 rg = gaussianRandom(uint(uv.x * size + uv.y));
+
+    // h0 k
+    float P = phillips_spectrum(k);
+    vec2 h0 = rg * sqrt(P / 2.0);
+
+    // h0 -k
+    vec2 k_minus = -k;
+    float P_minus = phillips_spectrum(k_minus);
+    vec2 h0_minus = rg * sqrt(P_minus / 2.0);
+
+    // Store in h0k image
+    imageStore(h0k, uv, vec4(h0.x, h0.y, h0_minus.x, h0_minus.y));
+}

shaders/lit.frag

@@ -11,6 +11,7 @@
 // #define DEBUG_ENV
 
 layout(location = 0) out vec4 out_color;
+layout(location = 1) out vec4 out_position;
 
 layout(location = 0) in vec3 in_normal;
 layout(location = 1) in vec2 in_uv;
@@ -41,21 +42,23 @@ layout(binding = 1) buffer PointLights {
     PointLight point_lights[];
 };
 
+uniform uint is_main;
+
 void main() {
     const vec3 normal_map = unpack_normal_map(texture(in_normal_texture, in_uv).xy);
     const vec3 normal = normal_map.x * in_tangent +
-                        normal_map.y * in_bitangent +
-                        normal_map.z * in_normal;
+    normal_map.y * in_bitangent +
+    normal_map.z * in_normal;
 
     const vec4 albedo_tex = texture(in_texture, in_uv);
     const vec3 base_color = in_color.rgb * albedo_tex.rgb * base_color_factor;
     const float alpha = albedo_tex.a;
 
-#ifdef ALPHA_TEST
+    #ifdef ALPHA_TEST
     if(alpha <= alpha_cutoff) {
         discard;
     }
-#endif
+    #endif
 
     const vec4 metal_rough_tex = texture(in_metal_rough, in_uv);
     const float roughness = metal_rough_tex.g * metal_rough_factor.y; // as per glTF spec
@@ -67,7 +70,7 @@ void main() {
 
     vec3 acc = texture(in_emissive, in_uv).rgb * emissive_factor;
     acc += eval_ibl(in_envmap, brdf_lut, normal, view_dir, base_color, metallic, roughness) * frame.ibl_intensity;
-    {
+    if (is_main == 0){
         float shadow = get_shadow(shadow_map, frame.sun_view_proj, in_position);
         if (shadow > 0.) {
             acc += shadow * frame.sun_color * eval_brdf(normal, view_dir, frame.sun_dir, base_color, metallic, roughness);
@@ -91,6 +94,7 @@ void main() {
 
 
     out_color = vec4(acc, alpha);
+    out_position = vec4(in_position, 1.);
 
 
 #ifdef DEBUG_NORMAL
@@ -108,5 +112,4 @@ void main() {
 #ifdef DEBUG_ENV
     out_color = vec4(texture(in_envmap, normal).rgb, 1.0);
 #endif
-}
-
+}