Ported volumetric shader to compute

- Added depth prepass for vegetation rendering
- Fixed CMakeLists.txt

data/shader/vegetation/depth.fsh

@@ -0,0 +1,16 @@
+#ifdef OPACITY_MAP
+layout(binding = 1) uniform sampler2D opacityMap;
+#endif
+
+in vec3 positionVS;
+in vec2 texCoordVS;
+
+void main() {
+
+#ifdef OPACITY_MAP
+	float opacity = texture(opacityMap, texCoordVS).r;
+	if (opacity < 0.2)
+		discard;
+#endif
+
+}

data/shader/vegetation/depth.vsh

@@ -0,0 +1,37 @@
+#include <../wind.hsh>
+#include <buffers.hsh>
+
+// Per vertex attributes
+layout(location=0) in vec3 vPosition;
+layout(location=2) in vec2 vTexCoord;
+
+// Vertex out parameters
+out vec3 positionVS;
+out vec2 texCoordVS;
+
+// Uniforms
+uniform mat4 pMatrix;
+uniform mat4 vMatrix;
+
+uniform float time;
+uniform float deltaTime;
+
+uniform bool invertUVs;
+
+// Functions
+void main() {
+
+	Instance instance = culledInstanceData[gl_InstanceID];
+	texCoordVS = invertUVs ? vec2(vTexCoord.x, 1.0 - vTexCoord.y) : vTexCoord;
+
+	mat4 mvMatrix = vMatrix;
+
+	vec3 position = instance.position.xyz + vPosition;
+	position = instance.position.xyz + WindAnimation(vPosition, time, instance.position.xyz);
+
+	vec4 positionToCamera = mvMatrix * vec4(position, 1.0);
+	positionVS = positionToCamera.xyz;
+
+	gl_Position = pMatrix * positionToCamera;
+
+}

data/shader/vegetation/instanceData.csh

@@ -42,7 +42,7 @@ void main() {
     Instance instance = instanceData[idx];
 
     cull = !IsInstanceVisible(instance, meshInfo) ||
-        distance(instance.position.xyz, cameraLocation) > 400.0;
+        distance(instance.position.xyz, cameraLocation) > 200.0;
 
     if (!cull) {
         uint instanceOffset = atomicAdd(lodCounters[counterIdx], 1u);

data/shader/vegetation/vegetation.vsh

@@ -36,10 +36,8 @@ uniform mat4 pMatrix;
 uniform mat4 vMatrix;
 
 uniform float time;
-uniform float deltaTime;
 
 uniform bool invertUVs;
-uniform bool staticMesh;
 
 uniform mat4 pvMatrixLast;
 uniform mat4 pvMatrixCurrent;
@@ -52,7 +50,6 @@ void main() {
 
 	mat4 mvMatrix = vMatrix;
 
-	// Move any animation code to their own compute shaders
 	vec3 position = instance.position.xyz + vPosition;
 
 	position = instance.position.xyz + WindAnimation(vPosition, time, instance.position.xyz);

data/shader/volumetric/volumetric.csh

@@ -0,0 +1,118 @@
+#ifdef AE_TEXTURE_SHADOW_LOD
+#extension GL_EXT_texture_shadow_lod : require
+#endif
+
+layout (local_size_x = 8, local_size_y = 8) in;
+
+#include <../structures>
+#include <../common/convert.hsh>
+#include <../common/utility.hsh>
+#include <fog.hsh>
+
+layout(binding = 0) uniform sampler2D depthTexture;
+layout(binding = 1) uniform sampler2DArrayShadow cascadeMaps;
+layout(binding = 2) writeonly uniform image2D volumetricImage;
+
+uniform Light light;
+uniform int sampleCount;
+uniform vec2 framebufferResolution;
+uniform float intensity;
+uniform mat4 ivMatrix;
+
+vec3 ComputeVolumetric(vec3 fragPos, vec2 texCoords);
+
+void main() {
+
+    ivec2 pixel = ivec2(gl_GlobalInvocationID);
+    if (pixel.x > imageSize(volumetricImage).x ||
+        pixel.y > imageSize(volumetricImage).y)
+        return;
+
+	vec2 texCoord = (vec2(pixel) + 0.5) / vec2(imageSize(volumetricImage));
+
+    float depth = textureLod(depthTexture, texCoord, 0.0).r;
+    vec3 pixelPos = ConvertDepthToViewSpace(depth, texCoord);
+
+    vec3 radiance = ComputeVolumetric(pixelPos, texCoord);
+    imageStore(volumetricImage, pixel, vec4(radiance, 0.0));
+
+}
+
+const float ditherPattern[16] = float[](0.0, 0.5, 0.125, 0.625, 0.75, 0.22, 0.875, 0.375,
+		0.1875, 0.6875, 0.0625, 0.5625, 0.9375, 0.4375, 0.8125, 0.3125);
+
+vec3 ComputeVolumetric(vec3 fragPos, vec2 texCoords) {
+
+    vec3 viewPosition = vec3(ivMatrix * vec4(fragPos, 1.0));
+
+    // We compute this in view space
+    vec3 rayVector = fragPos;
+    float rayLength = length(rayVector);
+    vec3 rayDirection = rayVector / rayLength;
+    float stepLength = rayLength / float(sampleCount);
+    vec3 stepVector = rayDirection * stepLength;
+
+    vec3 foginess = vec3(0.0);
+
+	texCoords = (0.5 * texCoords + 0.5) * framebufferResolution;
+
+	float ditherValue = ditherPattern[(int(texCoords.x) % 4) * 4 + int(texCoords.y) % 4];
+	vec3 currentPosition = stepVector * ditherValue;
+
+	int cascadeIndex = 0;
+	int lastCascadeIndex = 0;
+	mat4 cascadeMatrix = light.shadow.cascades[0].cascadeSpace;
+
+    for (int i = 0; i < sampleCount; i++) {
+
+		float distance = -currentPosition.z;
+
+		int cascadeIndex = 0;
+
+        cascadeIndex = distance >= light.shadow.cascades[0].distance ? 1 : cascadeIndex;
+        cascadeIndex = distance >= light.shadow.cascades[1].distance ? 2 : cascadeIndex;
+        cascadeIndex = distance >= light.shadow.cascades[2].distance ? 3 : cascadeIndex;
+        cascadeIndex = distance >= light.shadow.cascades[3].distance ? 4 : cascadeIndex;
+        cascadeIndex = distance >= light.shadow.cascades[4].distance ? 5 : cascadeIndex;
+
+        cascadeIndex = min(light.shadow.cascadeCount - 1, cascadeIndex);
+
+        if (lastCascadeIndex != cascadeIndex) {
+            cascadeMatrix = light.shadow.cascades[0].cascadeSpace;
+            cascadeMatrix = cascadeIndex > 0 ? light.shadow.cascades[1].cascadeSpace : cascadeMatrix;
+            cascadeMatrix = cascadeIndex > 1 ? light.shadow.cascades[2].cascadeSpace : cascadeMatrix;
+            cascadeMatrix = cascadeIndex > 2 ? light.shadow.cascades[3].cascadeSpace : cascadeMatrix;
+            cascadeMatrix = cascadeIndex > 3 ? light.shadow.cascades[4].cascadeSpace : cascadeMatrix;
+            cascadeMatrix = cascadeIndex > 4 ? light.shadow.cascades[5].cascadeSpace : cascadeMatrix;         
+        }
+
+		lastCascadeIndex = cascadeIndex;
+
+        vec4 cascadeSpace = cascadeMatrix * vec4(currentPosition, 1.0);
+        cascadeSpace.xyz /= cascadeSpace.w;
+
+        cascadeSpace.xyz = cascadeSpace.xyz * 0.5 + 0.5;
+
+#ifdef AE_TEXTURE_SHADOW_LOD
+        // This fixes issues that can occur at cascade borders
+        float shadowValue = textureLod(cascadeMaps, 
+            vec4(cascadeSpace.xy, cascadeIndex, cascadeSpace.z), 0);
+#else
+        float shadowValue = texture(cascadeMaps, 
+            vec4(cascadeSpace.xy, cascadeIndex, cascadeSpace.z));
+#endif
+
+        vec3 worldPosition = vec3(ivMatrix * vec4(currentPosition, 1.0));
+
+        float fogAmount = fogEnabled ? (1.0 - saturate(ComputeVolumetricFog(viewPosition, worldPosition))) : 1.0;
+        float NdotL = dot(rayDirection, light.direction);
+
+        foginess += shadowValue * fogAmount * ComputeScattering(NdotL) * light.color;
+
+        currentPosition += stepVector;
+
+    }
+
+    return foginess / float(sampleCount) * intensity;
+
+}

data/shader/volumetric/volumetricResolve.csh

@@ -13,11 +13,11 @@ uniform vec3 cameraLocation;
 
 void main() {
 
-    if (gl_GlobalInvocationID.x > imageSize(resolveImage).x ||
-        gl_GlobalInvocationID.y > imageSize(resolveImage).y)
+    ivec2 pixel = ivec2(gl_GlobalInvocationID);
+    if (pixel.x > imageSize(resolveImage).x ||
+        pixel.y > imageSize(resolveImage).y)
         return;
 
-    ivec2 pixel = ivec2(gl_GlobalInvocationID);
 	vec2 texCoord = (vec2(pixel) + 0.5) / vec2(imageSize(resolveImage));
 
 	float depth = texelFetch(depthTexture, pixel, 0).r;

demo/App.h

@@ -15,7 +15,7 @@
 class App : public Atlas::EngineInstance {
 
 public:
-	App() : EngineInstance("Atlas Engine", 1280, 720, WINDOW_FLAGS) {}
+	App() : EngineInstance("Atlas Engine Demo", 1280, 720, WINDOW_FLAGS) {}
 
 	virtual void LoadContent() final;
 

src/CMakeLists.txt

@@ -114,7 +114,7 @@ set(ATLAS_ENGINE_COMPILE_DEFINITIONS ${ATLAS_ENGINE_COMPILE_DEFINITIONS} AE_API_
 endif()
 
 if (ATLAS_EXPORT_MAIN)
-set(ATLAS_ENGINE_MAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/Main.cpp PARENT_SCOPE)
+set(ATLAS_ENGINE_MAIN_FILE ${CMAKE_CURRENT_SOURCE_DIR}/Main.cpp CACHE INTERNAL "Make main global")
 list(FILTER ATLAS_ENGINE_SOURCE_FILES EXCLUDE REGEX "(^.*\/|^)Main\.cpp$")
 endif()
 

src/renderer/SSAORenderer.cpp

@@ -6,7 +6,7 @@ namespace Atlas {
 
         SSAORenderer::SSAORenderer() {
 
-            blurFilter.CalculateBoxFilter(3);
+            blurFilter.CalculateBoxFilter(6);
 
             ssaoShader.AddStage(AE_COMPUTE_STAGE, "ao/ssao.csh");