Connected heightmaps, please read the readme.

There is many features in this commit, one of more most important:
1- Connected heightmaps. All heightmaps are connected using global UV position (chunk tile position) plus image UV as constant noise value in FBM.
2- Fixed mouse crashing?
3- PBR lighting not working in long distances.
4- Performance related issue.

Known issues:
1- Chunking performance.
2- GPU memory leaks or something else.
3- Many buffer gen & delete calls.

Thank you for reading.

Author: mrsrina

README.md

@@ -1,6 +1,6 @@
 # AGK
 
-Anubis Graphics Kit (AGK) is a photo-realism rendering engine made in OpenGL 4 for SDL2, the purpose of this engine is to do rendering tests and implement impirical rendering equations, techniques, concetps & specifically the umbrealla PBR.  
+Anubis Graphics Kit (AGK) is a photo-realism rendering engine made in OpenGL 4 for SDL2, the purpose of this engine is to do rendering tests and implement empirical rendering equations, techniques, concepts & specifically the umbrella PBR.  
 There is an official researcher article being write together with this project to investigate a way to connect heightmaps. The research is not linked to any institution, perhaps I will publish here at the ends of article project,  
 but VokeGpu will keep update this engine project.
 
@@ -24,7 +24,7 @@ The location of executables is in `./build/`, choose your system and run Anubis
 * Dynamic input system.
 * ~~Motion blur~~.
 * ~~Screen space occlusion ambient (SSAO)~~.
-* ~~Connected heightmaps.~~
+* Connected heightmaps.
 * ~~Subsurface scattering~~.
 * ~~Depth of field~~.
 * ~~Animation.~~
@@ -37,11 +37,14 @@ One of most important rendering technique used here is the umbrella of physicall
 The BRDF make the terrain and world objects looks soft and realistic at some point, the visual effect also do subsurface scattering or known as BSSDF (bidirectional subsurface scattering distribution function) effect.
 ![Alt text](/splash/splash-brdf-2.png?raw=true)
 
-The terrain is procedural generated using compute shaders and FBM equation with perlin noise from Ken Perlin, the volume of terrain processed from grey-scale is real-time computed using tessellation shader with 4 patches, credits to [learnopengl](https://learnopengl.com) which I have used as book to learn about terrain generator.
-For rendering all terrain AGK come with a chunking system.
-![Alt text](/splash/splash-terrain-1.png)
-
+The terrain is procedural generated using compute shaders and FBM equation with perlin noise from Ken Perlin, the volume of terrain processed from grey-scale is real-time computed using tessellation shader with 4 patches, credits to [learnopengl](https://learnopengl.com) which I have used as book to learn about terrain rendering.
+For rendering all terrain AGK come with a chunking system.  
 The GUI is powered by VokeGpu [ekg ui library](https://github.com/vokegpu/ekg-ui-library) a high-performance library made in OpenGL for SDL2 written in C++.
+All detailed process are include in the article writen for this project, called Real-Time Terrain Generator by Rina.
+
+![Alt text](/splash/splash-terrain-6.png)
+![Alt text](/splash/splash-terrain-rochoso.png)
+![Alt text](/splash/splash-terrain-arenoso.png)
 
 # License & credits
 The project is under license MIT.  

build/linux/data/effects/coordinate.debug.frag

@@ -0,0 +1,8 @@
+#version 450
+
+layout (location = 0) out vec4 vFragColor;
+in vec3 vColor;
+
+void main() {
+    vFragColor = vec4(vColor, 1.0f);
+}

build/linux/data/effects/coordinate.debug.vert

@@ -0,0 +1,12 @@
+#version 450
+
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+
+uniform mat4 uMVP;
+out vec3 vColor;
+
+void main() {
+    gl_Position = uMVP * vec4(aPos, 1.0f);
+    vColor = aColor;
+}

build/linux/data/effects/material.brdf.pbr.frag

@@ -1,93 +1,103 @@
 #version 450 core
 #define PI 3.1415926535897932384626433832795
 
-layout (location = 0) out vec4 FragColor;
+layout (location = 0) out vec4 vFragColor;
 
-in vec3 Pos;
-in vec2 Texcoord;
-in vec3 Normal;
+in vec3 vPos;
+in vec2 vTexCoord;
+in vec3 vNormal;
+
+uniform vec3 uCameraPos;
+uniform float uAmbientColor;
+uniform int uLightAmount;
+uniform float uGamma = 1.0f;
+
+vec3 mMaterialColor;
 
-uniform vec3 CameraPosition;
 uniform struct {
-    vec3 Color;
-    bool Metal;
-    float Rough;
-} Material;
+    vec3 uColor;
+    bool uMetal;
+    float uRough;
+} uMaterial;
 
-uniform int LoadedLightLen;
 uniform struct {
-    vec3 Intensity;
-    bool Directional;
-    vec3 POD;
-} Light[100];
-
-vec3 SchlickFresnel(float lDotH) {
-    vec3 f0 = vec3(0.04);
-    if (Material.Metal) {
-        f0 = Material.Color;
-    }
+    vec3 uIntensity;
+    bool uDirectional;
+    vec3 uVector;
+} uLight[100];
 
-    return f0 + (1 - f0) * pow(clamp(1.0 - lDotH, 0.0f, 1.0), 5.0);
+uniform struct {
+    vec2 uDistance;
+    vec3 uColor;
+} uFog;
+
+vec3 shlickFresnel(float lDotH) {
+    vec3 f0 = vec3(0.04f);
+    if (uMaterial.uMetal) {
+        f0 = mMaterialColor;
+    }
+    return f0 + (1 - f0) * pow(clamp(1.0f - lDotH, 0.0f, 1.0f), 5.0f);
 }
 
-float GeometrySmith(float dotProduct) {
-    float k = (Material.Rough + 1.0) * (Material.Rough + 1.0) / 8.0;
-    float denom = dotProduct * (1 - k) + k;
-    return 1.0 / denom;
+float geometrySmith(float dotProd) {
+    float k = (uMaterial.uRough + 1.0f) * (uMaterial.uRough + 1.0f) / 8.0f;
+    float denom = dotProd * (1.0f - k) + k;
+    return 1.0f / denom;
 }
 
-float GGxDistribution(float nDotH) {
-    float alpha2 = Material.Rough * Material.Rough * Material.Rough * Material.Rough;
-    float d = (nDotH * nDotH) * (alpha2 - 1) + 1;
-    return alpha2 / (PI * d * d);
+float ggxDistribution(float nDotH) {
+    float a2 = uMaterial.uRough * uMaterial.uRough * uMaterial.uRough * uMaterial.uRough;
+    float d = (nDotH * nDotH) * (a2 - 1.0f) + 1.0f;
+    return a2 / (PI * d * d);
 }
 
-vec3 BRDFunction(vec3 n, vec3 v, int lightIndex) {
-    vec3 diffuse = vec3(0.0);
-    if (!Material.Metal) {
-        diffuse = Material.Color;
+vec3 bidirecionalReflectanceDistributionFunc(vec3 n, vec3 v, int index) {
+    vec3 diffuse = vec3(0.0f);
+    if (!uMaterial.uMetal) {
+        diffuse = mMaterialColor;
     }
 
-    vec3 intensity = Light[lightIndex].Intensity;
-    vec3 l = vec3(0.0);
+    vec3 intensity = uLight[index].uIntensity;
+    vec3 l = vec3(0.0f);
 
-    if (Light[lightIndex].Directional) {
-        l = normalize(Light[lightIndex].POD);
+    if (uLight[index].uDirectional) {
+        l = normalize(uLight[index].uVector);
     } else {
-        l = Light[lightIndex].POD - Pos;
-        float distance = length(l);
+        l = uLight[index].uVector - vPos;
+        float dist = length(l);
         l = normalize(l);
-        intensity /= (distance * distance);
+        intensity /= (dist * dist);
     }
 
-    float Wrap = 0.0;
-
     vec3 h = normalize(v + l);
     float nDotH = dot(n, h);
     float lDotH = dot(l, h);
-    float nDotL = max(dot(l, n), 0.0);
+    float nDotL = max(dot(n, l), 1.0f);
     float nDotV = dot(n, v);
-    vec3 spec = 0.25 * GGxDistribution(nDotH) * SchlickFresnel(lDotH) * GeometrySmith(nDotL) * GeometrySmith(nDotV);
 
-    return (diffuse + PI * spec) * intensity * nDotL;
+    /* 0.25f == fracion of 4 */
+    vec3 specular = 0.25f * ggxDistribution(nDotH) * shlickFresnel(lDotH) * geometrySmith(nDotL) * geometrySmith(nDotV);
+    return (diffuse + PI * specular) * intensity * nDotL;
 }
 
 void main() {
-    vec3 color = vec3(0.0f);
-    
-    if (Material.Rough == -1) {
-        color = Material.Color;
+    float dist = length(vPos);
+    float fogFactor = clamp((uFog.uDistance.y - dist) / (uFog.uDistance.y - uFog.uDistance.x), 0.0, 1.0);
+    mMaterialColor = uMaterial.uColor;
+    vec3 sum = mMaterialColor * uAmbientColor;
+
+    if (uMaterial.uRough == -1) {
+        sum = mMaterialColor;
     } else {
-        vec3 n = normalize(Normal);
-        vec3 v = normalize(CameraPosition - Pos);
+        vec3 n = normalize(vNormal);
+        vec3 v = normalize(uCameraPos - vPos);
 
         if (!gl_FrontFacing) n = -n;
-        for (int it = 0; it <= LoadedLightLen; it++) {
-            color += BRDFunction(n, v, it);
+        for (int index = 0; index <= uLightAmount; index++) {
+            sum += bidirecionalReflectanceDistributionFunc(n, v, index);
         }
-
-        color = pow(color, vec3(1.0 / 2.0));
     }
 
-    FragColor = vec4(color, 1.0f);
+    sum = mix(uFog.uColor, sum, fogFactor);
+    vFragColor = vec4(sum, 1.0f);
 }

build/linux/data/effects/material.brdf.pbr.vert

@@ -1,21 +1,22 @@
 #version 450 core
 
-layout (location = 0) in vec3 VertexPosition;
-layout (location = 1) in vec2 TextureCoordinate;
-layout (location = 2) in vec3 FaceNormal;
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec2 aTexCoord;
+layout (location = 2) in vec3 aNormal;
 
-out vec3 Pos;
-out vec2 Texcoord;
-out vec3 Normal;
+out vec3 vPos;
+out vec2 vTexCoord;
+out vec3 vNormal;
 
-uniform mat4 MVP;
-uniform mat4 MatrixModel;
-uniform mat3 MatrixNormal;
+uniform mat4 uMVP;
+uniform mat4 uModelMatrix;
+uniform mat3 uNormalMatrix;
 
 void main() {
-    Pos = (MatrixModel * vec4(VertexPosition, 1.0f)).xyz;
-    Texcoord = TextureCoordinate;
-    Normal = normalize(MatrixNormal * FaceNormal);
+    gl_Position = uMVP * vec4(aPos, 1.0f);
+    vec4 modelPos = uModelMatrix * vec4(aPos, 1.0f);
 
-    gl_Position = MVP * vec4(VertexPosition, 1.0f);
+    vPos = modelPos.xyz;
+    vTexCoord = aTexCoord;
+    vNormal = normalize(uNormalMatrix * aNormal);
 }

build/linux/data/effects/processing.post.frag

@@ -1,78 +1,82 @@
-#version 450 core
+#version 450
 
-layout (location = 0) out vec4 FragColor;
-layout (binding = 0) uniform sampler2D FramebufferTexture;
-layout (binding = 1) uniform sampler2D DepthbufferTexture;
+layout (location = 0) out vec4 vFragColor;
+layout (binding = 0) uniform sampler2D uTexture;
+layout (binding = 1) uniform sampler2D uDepthSampler;
 
-in vec4 Rect;
-in vec2 Texcoord;
+in vec4 vRect;
+uniform vec4 uColor;
 
-uniform vec4 Color;
-
-uniform mat3 RGBtoXYZ = mat3(
-    0.4124564, 0.2126729, 0.0193339,
-    0.3575761, 0.7151522, 0.1191920,
-    0.1804375, 0.0721750, 0.9503041
+const mat3 RGBtoXYZ = mat3(
+    0.4124564f, 0.2126729f, 0.0193339f,
+    0.3575761f, 0.7151522f, 0.1191920f,
+    0.1804375f, 0.0721750f, 0.9503041f
 );
 
-uniform mat3 XYZtoRGB = mat3(
-    3.2404542, -0.9692660, 0.0556434,
-    -1.5371385, 1.8760108, -0.2040259,
-    -0.4985314, 0.0415560, 1.0572252
+const mat3 XYZtoRGB = mat3(
+    3.2404542f, -0.9692660f, 0.0556434f,
+    -1.5371385f, 1.8760108f, -0.2040259f,
+    -0.4985314f, 0.0415560f, 1.0572252f
 );
 
-uniform float Exposure = 0.35;
-uniform float White = 0.928;
-uniform float AveLuminance;
-uniform mat4 PreviousMVP;
-uniform mat4 InverseMVP;
+uniform mat4 uMVP;
+uniform mat4 uInverseMVP;
 
 uniform struct {
-    bool HighDynamicRange;
-    float AveLuminanceHDR;
-} Effects;
+    bool uEnabled;
+    float uAverageLuminance;
+    float uExposure;
+    float uWhite;
+} uHDR;
 
 void main() {
-    vec4 sum = texture(FramebufferTexture, Texcoord);
-    vec4 depw = texture(DepthbufferTexture, Texcoord);
-    vec4 c = sum;
-    float dep = depw.w;
-
-    vec4 h = vec4(Texcoord.x * 2 - 1.0f, (1.0f - Texcoord.y) * 2 - 1, dep, 1);
-    vec4 d = h * InverseMVP;
-    vec4 worldPos = vec4(d.xyz / d.w, 1);
-    vec4 currentPos = h;
-
-    vec4 previousPos = worldPos * PreviousMVP;
-    previousPos /= previousPos.w;
-
-    vec2 texcoord = Texcoord;
-    vec2 velocity = (currentPos.xy - previousPos.xy);
-
-    for (int i = 1; i < 5; ++i) {
-        texcoord += velocity;
-        vec4 color = texture(FramebufferTexture, texcoord);
-        sum += color;
+    vec2 fragCoord = gl_FragCoord.xy / textureSize(uTexture, 0);
+    vec4 framebufferColor = texture(uTexture, fragCoord);
+    vec4 framebufferDepth = texture(uDepthSampler, fragCoord);
+
+    float dep = framebufferDepth.r;
+    vec4 h = vec4(fragCoord.x * 2 - 1, (1.0f - fragCoord.y) * 2 - 1, dep, 1.0f);
+    vec4 d = uInverseMVP * h;
+    vec4 w = d / d.w;
+
+    vec4 currPos = h;
+    vec4 prevPos = uMVP * w;
+    prevPos = prevPos / prevPos.w;
+
+    vec2 velocity = (currPos.xy - prevPos.xy);
+    vec2 texCoord = fragCoord + velocity;
+    int numSamples = 1;
+    if (velocity.x == 0 && velocity.y == 0) {
+        numSamples = 1;
+    }
+
+    for (int i = 1; i < numSamples; ++i) {
+        texCoord += velocity;
+        vec4 currColor = texture(uTexture, texCoord);
+        framebufferColor += currColor;
     }
 
-    sum = vec4(sum.xyz / 5, 1.0f);
+    vec4 sum = framebufferColor / numSamples;
+
+    if (uHDR.uEnabled) {
+        float white = 0.928f;
+        float exposure = 0.35f;
 
-    if (Effects.HighDynamicRange) {
         vec3 xyzCol = RGBtoXYZ * vec3(sum);
 
         float xyzSum = xyzCol.x + xyzCol.y + xyzCol.z;
-        vec3 xyYCol = vec3(0);
-        if (xyzSum > 0.0) xyYCol = vec3(xyzCol.x / xyzSum, xyzCol.y / xyzSum, xyzCol.y);
+        vec3 xyYCol = vec3(0.0f);
+        if (xyzSum > 0.0f) xyYCol = vec3(xyzCol.x / xyzSum, xyzCol.y / xyzSum, xyzCol.y);
 
-        float l = (Exposure * xyYCol.z) / AveLuminance;
-        l = (l * (1 + l / (White * White))) / (1 + l);
+        float l = (exposure * xyYCol.z) / uHDR.uAverageLuminance;
+        l = (l * (1 + l / (white * white))) / (1.0f + l);
 
         xyzCol.x = (l * xyYCol.x) / (xyYCol.y);
         xyzCol.y = l;
-        xyzCol.z = (l * (1 - xyYCol.x - xyYCol.y)) / xyYCol.y;
+        xyzCol.z = (l * (1.0f - xyYCol.x - xyYCol.y)) / xyYCol.y;
 
-        sum = vec4(XYZtoRGB * xyzCol, 1.0);
+        sum = vec4(XYZtoRGB * xyzCol, 1.0f);
     }
 
-    FragColor = sum;
+    vFragColor = sum;
 }