Multisampling and specialization constants

Author: lwjglgamedev

booksamples/.gitignore

@@ -1,8 +1,10 @@
 .idea/
+.gradle/
 .settings/
 *.iml
 .classpath
 .factorypath
 .project
 target/
+build/
 *.log

booksamples/chapter-12/resources/shaders/lighting_fragment.glsl

@@ -3,7 +3,7 @@
 // developed by Joey de Vries, https://twitter.com/JoeyDeVriez, and licensed under the terms of the CC BY-NC 4.0,
 // https://creativecommons.org/licenses/by-nc/4.0/legalcode
 
-const int MAX_LIGHTS = 10;
+layout (constant_id = 0) const int MAX_LIGHTS = 10;
 const float PI = 3.14159265359;
 
 // Always use vec4 (minimum alighnment)

booksamples/chapter-12/resources/shaders/lighting_fragment.glsl.spv

@@ -0,0 +1,170 @@
+#version 450
+// CREDITS: Most of the functions here have been obtained from this link: https://learnopengl.com/PBR
+// developed by Joey de Vries, https://twitter.com/JoeyDeVriez, and licensed under the terms of the CC BY-NC 4.0,
+// https://creativecommons.org/licenses/by-nc/4.0/legalcode
+
+layout (constant_id = 0) const int MAX_LIGHTS = 10;
+layout (constant_id = 1) const int NUM_SAMPLES = 8;
+const float PI = 3.14159265359;
+
+// Always use vec4 (minimum alighnment)
+struct Light {
+    vec4 position;
+    vec4 color;
+};
+
+layout(location = 0) in vec2 inTextCoord;
+
+layout(location = 0) out vec4 outFragColor;
+
+layout(set = 0, binding = 0) uniform sampler2DMS albedoSampler;
+layout(set = 0, binding = 1) uniform sampler2DMS normalsSampler;
+layout(set = 0, binding = 2) uniform sampler2DMS pbrSampler;
+layout(set = 0, binding = 3) uniform sampler2DMS depthSampler;
+layout(set = 1, binding = 0) uniform UBO {
+    vec4 ambientLightColor;
+    uint count;
+    Light lights[MAX_LIGHTS];
+} lights;
+layout(set = 2, binding = 0) uniform ProjUniform {
+    mat4 invProjectionMatrix;
+} projUniform;
+
+vec4 resolve(sampler2DMS tex, ivec2 uv)
+{
+    vec4 result = vec4(0.0);
+    for (int i = 0; i < NUM_SAMPLES; i++)
+    {
+        vec4 val = texelFetch(tex, uv, i);
+        result += val;
+    }
+    // Average resolved samples
+    return result / float(NUM_SAMPLES);
+}
+
+vec3 fresnelSchlick(float cosTheta, vec3 F0)
+{
+    return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+float DistributionGGX(vec3 N, vec3 H, float roughness)
+{
+    float a      = roughness*roughness;
+    float a2     = a*a;
+    float NdotH  = max(dot(N, H), 0.0);
+    float NdotH2 = NdotH*NdotH;
+
+    float num   = a2;
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+
+    return num / denom;
+}
+
+float GeometrySchlickGGX(float NdotV, float roughness)
+{
+    float r = (roughness + 1.0);
+    float k = (r*r) / 8.0;
+
+    float num   = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+
+    return num / denom;
+}
+float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
+{
+    float NdotV = max(dot(N, V), 0.0);
+    float NdotL = max(dot(N, L), 0.0);
+    float ggx2  = GeometrySchlickGGX(NdotV, roughness);
+    float ggx1  = GeometrySchlickGGX(NdotL, roughness);
+
+    return ggx1 * ggx2;
+}
+
+vec3 calculateLight(Light light, vec3 lightDirection, vec3 position, vec3 normal, vec3 albedo,
+float metallic, float roughness, float attenuation) {
+    vec3 result;
+
+    vec3 N = normalize(normal);
+    vec3 L = normalize(lightDirection);
+    vec3 V = normalize(-position);
+    vec3 H = normalize(L + V);
+
+    vec3 F0 = vec3(0.04);
+    F0 = mix(F0, albedo, metallic);
+
+    vec3 Lo = vec3(0.0);
+    vec3 radiance = light.color.rgb * attenuation;
+
+    // cook-torrance brdf
+    float NDF = DistributionGGX(N, H, roughness);
+    float G   = GeometrySmith(N, V, L, roughness);
+    vec3 F    = fresnelSchlick(max(dot(H, V), 0.0), F0);
+
+    vec3 kS = F;
+    vec3 kD = vec3(1.0) - kS;
+    kD *= 1.0 - metallic;
+
+    vec3 numerator    = NDF * G * F;
+    float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0);
+    vec3 specular     = numerator / max(denominator, 0.001);
+
+    // add to outgoing radiance Lo
+    float NdotL = max(dot(N, L), 0.0);
+    Lo += (kD * albedo / PI + specular) * radiance * NdotL;
+
+    return Lo;
+}
+
+vec3 calculateDirectionalLight(Light light, vec3 position, vec3 normal, vec3 color,
+float metallic, float roughness) {
+    float attenuation = 1.0;
+    return calculateLight(light, light.position.xyz, position, normal, color, metallic, roughness,
+    attenuation);
+}
+
+vec3 calculatePointLight(Light light, vec3 position, vec3 normal, vec3 color,
+float metallic, float roughness) {
+    vec3 lightDirection = light.position.xyz - position;
+    float dist = length(lightDirection) * 0.005;
+    float attenuation = 1.0 / (dist * dist);
+    return calculateLight(light, lightDirection, position, normal, color, metallic, roughness,
+    attenuation);
+}
+
+void main() {
+    ivec2 textSize = textureSize(albedoSampler);
+    ivec2 uv = ivec2(inTextCoord * textSize);
+
+    vec3 albedo = resolve(albedoSampler, uv).rgb;
+    vec3 normal = normalize(2.0 * resolve(normalsSampler, uv).rgb  - 1.0);
+    vec3 pbrSampledValue = resolve(pbrSampler, uv).rgb;
+    float ao = pbrSampledValue.r;
+    float roughness = pbrSampledValue.g;
+    float metallic = pbrSampledValue.b;
+
+    // Retrieve position from depth
+    vec4 clip    = vec4(inTextCoord.x * 2.0 - 1.0, inTextCoord.y * -2.0 + 1.0, resolve(depthSampler, uv).x, 1.0);
+    vec4 world_w = projUniform.invProjectionMatrix * clip;
+    vec3 pos     = world_w.xyz / world_w.w;
+
+    // Calculate lighting
+    vec3 lightColor = vec3(0.0);
+    vec3 ambientColor = vec3(0.5);
+    for (uint i = 0U; i < lights.count; i++)
+    {
+        Light light = lights.lights[i];
+        if (light.position.w == 0)
+        {
+            lightColor += calculateDirectionalLight(light, pos, normal, albedo, metallic, roughness);
+        }
+        else
+        {
+            lightColor += calculatePointLight(light, pos, normal, albedo, metallic, roughness);
+        }
+    }
+
+    vec3 ambient = lights.ambientLightColor.rgb * albedo * ao;
+
+    outFragColor = vec4(pow(ambient + lightColor, vec3(0.4545)), 1.0);
+}

booksamples/chapter-12/resources/shaders/lighting_fragment_multi.glsl

@@ -8,6 +8,7 @@
 public class EngineProperties {
     private static final float DEFAULT_FOV = 60.0f;
     private static final int DEFAULT_MAX_MATERIALS = 500;
+    private static final int DEFAULT_MULTISAMPLING = 1;
     private static final int DEFAULT_REQUESTED_IMAGES = 3;
     private static final int DEFAULT_UPS = 30;
     private static final float DEFAULT_Z_FAR = 100.f;
@@ -18,6 +19,7 @@ public class EngineProperties {
     private String defaultTexturePath;
     private float fov;
     private int maxMaterials;
+    private int multiSampling;
     private String physDeviceName;
     private int requestedImages;
     private boolean shaderRecompilation;
@@ -44,6 +46,7 @@ private EngineProperties() {
             zFar = Float.parseFloat(props.getOrDefault("zFar", DEFAULT_Z_FAR).toString());
             defaultTexturePath = props.getProperty("defaultTexturePath");
             maxMaterials = Integer.parseInt(props.getOrDefault("maxMaterials", DEFAULT_MAX_MATERIALS).toString());
+            multiSampling = Integer.parseInt(props.getOrDefault("multiSampling", DEFAULT_MULTISAMPLING).toString());
         } catch (IOException excp) {
             LOGGER.error("Could not read [{}] properties file", FILENAME, excp);
         }
@@ -68,6 +71,10 @@ public int getMaxMaterials() {
         return maxMaterials;
     }
 
+    public int getMultiSampling() {
+        return multiSampling;
+    }
+
     public String getPhysDeviceName() {
         return physDeviceName;
     }

booksamples/chapter-12/resources/shaders/lighting_fragment_multi.glsl.spv

@@ -15,33 +15,33 @@ public class GeometryAttachments {
     private int height;
     private int width;
 
-    public GeometryAttachments(Device device, int width, int height) {
+    public GeometryAttachments(Device device, int width, int height, int numSamples) {
         this.width = width;
         this.height = height;
         attachments = new Attachment[NUMBER_ATTACHMENTS];
 
         int i = 0;
         // Albedo attachment
         Attachment attachment = new Attachment(device, width, height,
-                VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+                VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, numSamples);
         attachments[i] = attachment;
         i++;
 
         // Normals attachment
         attachment = new Attachment(device, width, height,
-                VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+                VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, numSamples);
         attachments[i] = attachment;
         i++;
 
         // PBR attachment
         attachment = new Attachment(device, width, height,
-                VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+                VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, numSamples);
         attachments[i] = attachment;
         i++;
 
         // Depth attachment
         attachment = new Attachment(device, width, height,
-                VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
+                VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, numSamples);
         attachments[i] = attachment;
         depthAttachmentPos = i;
     }

booksamples/chapter-12/src/main/java/org/vulkanb/eng/EngineProperties.java

@@ -3,17 +3,21 @@
 import org.apache.logging.log4j.*;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.vulkan.VkExtent2D;
+import org.vulkanb.eng.EngineProperties;
 import org.vulkanb.eng.graph.vk.*;
 
 import java.nio.LongBuffer;
 
+import static org.lwjgl.vulkan.VK10.VK_SAMPLE_COUNT_1_BIT;
+
 public class GeometryFrameBuffer {
 
     private static final Logger LOGGER = LogManager.getLogger();
 
     private FrameBuffer frameBuffer;
     private GeometryAttachments geometryAttachments;
     private GeometryRenderPass geometryRenderPass;
+    private int numSamples;
 
     public GeometryFrameBuffer(SwapChain swapChain) {
         LOGGER.debug("Creating GeometryFrameBuffer");
@@ -33,7 +37,17 @@ private void createAttachments(SwapChain swapChain) {
         VkExtent2D extent2D = swapChain.getSwapChainExtent();
         int width = extent2D.width();
         int height = extent2D.height();
-        geometryAttachments = new GeometryAttachments(swapChain.getDevice(), width, height);
+
+        numSamples = VK_SAMPLE_COUNT_1_BIT;
+        EngineProperties engProps = EngineProperties.getInstance();
+        int requestedSamples = engProps.getMultiSampling();
+        Device device = swapChain.getDevice();
+        if (requestedSamples > 0 && device.isSampleRateShading()) {
+            numSamples = device.getPhysicalDevice().supportsSampleCount(requestedSamples) ? requestedSamples : VK_SAMPLE_COUNT_1_BIT;
+        }
+        LOGGER.debug("Requested [{}] samples, using [{}]", requestedSamples, numSamples);
+
+        geometryAttachments = new GeometryAttachments(swapChain.getDevice(), width, height, numSamples);
     }
 
     private void createFrameBuffer(SwapChain swapChain) {
@@ -58,6 +72,10 @@ public FrameBuffer getFrameBuffer() {
         return frameBuffer;
     }
 
+    public int getNumSamples() {
+        return numSamples;
+    }
+
     public GeometryRenderPass getRenderPass() {
         return geometryRenderPass;
     }
@@ -68,4 +86,8 @@ public void resize(SwapChain swapChain) {
         createAttachments(swapChain);
         createFrameBuffer(swapChain);
     }
+
+    public void setNumSamples(int numSamples) {
+        this.numSamples = numSamples;
+    }
 }

booksamples/chapter-12/src/main/java/org/vulkanb/eng/graph/geometry/GeometryAttachments.java

@@ -134,7 +134,7 @@ private void createPipeline() {
         Pipeline.PipeLineCreationInfo pipeLineCreationInfo = new Pipeline.PipeLineCreationInfo(
                 geometryFrameBuffer.getRenderPass().getVkRenderPass(), shaderProgram, GeometryAttachments.NUMBER_COLOR_ATTACHMENTS,
                 true, true, GraphConstants.MAT4X4_SIZE,
-                new VertexBufferStructure(), geometryDescriptorSetLayouts);
+                new VertexBufferStructure(), geometryDescriptorSetLayouts, geometryFrameBuffer.getNumSamples());
         pipeLine = new Pipeline(pipelineCache, pipeLineCreationInfo);
         pipeLineCreationInfo.cleanup();
     }

booksamples/chapter-12/src/main/java/org/vulkanb/eng/graph/geometry/GeometryFrameBuffer.java

@@ -11,7 +11,6 @@
 
 public class GeometryRenderPass {
 
-    private static final int MAX_SAMPLES = 1;
     private Device device;
     private long vkRenderPass;
 
@@ -28,7 +27,7 @@ public GeometryRenderPass(Device device, Attachment[] attachments) {
                         .storeOp(VK_ATTACHMENT_STORE_OP_STORE)
                         .stencilLoadOp(VK_ATTACHMENT_LOAD_OP_DONT_CARE)
                         .stencilStoreOp(VK_ATTACHMENT_STORE_OP_DONT_CARE)
-                        .samples(MAX_SAMPLES)
+                        .samples(attachments[i].getSamples())
                         .initialLayout(VK_IMAGE_LAYOUT_UNDEFINED);
                 if (attachments[i].isDepthAttachment()) {
                     depthAttachmentPos = i;