Engine: More PBR shader support and full PBR textures support added (baseColor, normalTexture, metallicRoughnessTexture, emissiveTexture and occlusionTexture)

Author: amerkoleci

Alimer.slnx

@@ -21,6 +21,7 @@
   </Folder>
   <Folder Name="/assets/shaders/">
     <File Path="assets/Shaders/Alimer.hlsli" />
+    <File Path="assets/Shaders/BRDF.hlsli" />
     <File Path="assets/Shaders/IBL.slang" />
     <File Path="assets/Shaders/Math.hlsli" />
     <File Path="assets/Shaders/PBR.slang" />

assets/Shaders/BRDF.hlsli

@@ -0,0 +1,61 @@
+// Copyright (c) Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+#ifndef _ALIMER_BRDF__
+#define _ALIMER_BRDF__
+
+#include "Math.hlsli"
+
+float3 FresnelSchlick(in float LdotH, in float3 F0)
+{
+    return F0 + (1.f - F0) * pow(1.f - LdotH, 5.f);
+}
+
+float3 FresnelSchlickRoughness(float LdotH, float3 F0, float roughness)
+{
+    float v = 1.0f - roughness;
+    return F0 + (max(float3(v, v, v), F0) - F0) * pow(1.f - LdotH, 5.f);
+}
+
+float DistributionGGX(in float3 N, in float3 H, in float roughness)
+{
+    float a = roughness * roughness;
+    float a2 = a * a;
+    float NdotH = saturate(dot(N, H));
+    float NdotH2 = NdotH * NdotH;
+
+    float denom = (NdotH2 * (a2 - 1.f) + 1.f);
+    return a2 / max(denom * denom * Pi, 0.001f);
+}
+
+float GeometrySchlickGGX(in float NdotV, in float roughness)
+{
+    const float r = roughness + 1;
+    const float k = (r * r) / 8;
+
+    const float num = NdotV;
+    const float denom = NdotV * (1 - k) + k;
+
+    return num / denom;
+}
+
+float GeometrySmith(in float3 N, in float3 V, in float3 L, in float roughness)
+{
+    const float NdotV = max(dot(N, V), 0);
+    const float NdotL = max(dot(N, L), 0);
+    const float ggx2 = GeometrySchlickGGX(NdotV, roughness);
+    const float ggx1 = GeometrySchlickGGX(NdotL, roughness);
+    return ggx1 * ggx2;
+}
+
+// From https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile
+float2 envBRDFApprox(in float roughness, in float NdotV)
+{
+    float4 c0 = float4(-1.f, -0.0275f, -0.572f, 0.022f);
+    float4 c1 = float4(1.f, 0.0425f, 1.04f, -0.04f);
+    float4 r = roughness * c0 + c1;
+    float a004 = min(r.x * r.x, exp2(-9.28f * NdotV)) * r.x + r.y;
+    return float2(-1.04f, 1.04f) * a004 + r.zw;
+}
+
+#endif // _ALIMER_BRDF__

assets/Shaders/PBR.slang

@@ -1,6 +1,7 @@
 #include "Alimer.hlsli"
-#include "VertexInputOutput.hlsli"
+#include "BRDF.hlsli"
 #include "ShaderTypes.h"
+#include "VertexInputOutput.hlsli"
 
 struct SurfaceInfo
 {
@@ -25,10 +26,51 @@ struct SurfaceInfo
     float3 F0;
 };
 
+float3 getDiffuseLightColor(in float3 N)
+{
+    // TODO
+    // float width, height, numberOfLevels;
+    // environmentTexture.GetDimensions(0, width, height, numberOfLevels);
+
+    // const float diffuseLevel = float(numberOfLevels - 1);
+    // return environmentTexture.SampleLevel(environmentSampler, N, diffuseLevel).rgb;
+    return float3(1.0f, 1.0f, 1.0f);
+}
+
+float3 getSpecularLightColor(in float3 R, in float roughness)
+{
+    // TODO
+    // float width, height, numberOfLevels;
+    // environmentTexture.GetDimensions(0, width, height, numberOfLevels);
+    //
+    // const float rough = numberOfLevels * roughness * (2.0f - roughness);
+    // return environmentTexture.SampleLevel(environmentSampler, R, rough).rgb;
+    return float3(1.0f, 1.0f, 1.0f);
+}
+
+float3 pbrSurfaceColorIbl(in SurfaceInfo surface)
+{
+    float3 kS = FresnelSchlickRoughness(surface.NdotV, surface.F0, surface.roughness);
+    float3 kD = (float3(1.f, 1.f, 1.f) - kS) * (1.f - surface.metalness);
+    float3 irradiance = getDiffuseLightColor(surface.N);
+    float3 diffuse = irradiance * surface.diffuseColor;
+
+    float3 prefilteredColor = getSpecularLightColor(surface.R, surface.roughness);
+    float2 envBrdf = envBRDFApprox(surface.roughness, surface.NdotV);
+    float3 specular = prefilteredColor * (surface.specularColor * envBrdf.x + envBrdf.y);
+
+    float3 ambient = (kD * diffuse + specular) * surface.ao;
+    return ambient;
+}
+
 // Material (space 0)
-ConstantBuffer<PBRMaterialData> material : register(b0);
+ConstantBuffer<PBRMaterialUniforms> material : register(b0);
 Texture2D<float4> baseColorTexture : register(t0);
 Texture2D<float4> normalTexture : register(t1);
+Texture2D<float4> metallicRoughnessTexture : register(t2);
+Texture2D<float4> emissiveTexture : register(t3);
+Texture2D<float4> occlusionTexture : register(t4);
+// Texture2D<float4> transmissionTexture : register(t5, space1);
 SamplerState pbrSampler : register(s0);
 
 [shader("pixel")]
@@ -52,13 +94,59 @@ float4 fragmentMain(in VertexOutput input, in bool isFrontFace: SV_IsFrontFace)
     {
         float3 N = float3(normalTexture.Sample(pbrSampler, input.TexCoord0).rg, 1.f);
         N = N * 2.f - 1.f;
-        //N.rg *= material.GetNormalMapStrength();
+        // N.rg *= material.GetNormalMapStrength();
         surface.N = normalize(mul(N, TBN));
         if (!isFrontFace) // MATERIAL_DOUBLE_SIDED?
         {
             surface.N = -surface.N;
         }
     }
 
-    return baseColor;
+    surface.NdotV = saturate(dot(surface.N, surface.V));
+    surface.R = reflect(-surface.V, surface.N);
+
+    const float3 color = input.Color * baseColor.rgb;
+    surface.alpha = baseColor.a;
+    surface.ao = material.occlusionStrength * occlusionTexture.Sample(pbrSampler, input.TexCoord0).r;
+    surface.emissive = material.emissiveFactor * emissiveTexture.Sample(pbrSampler, input.TexCoord0).rgb;
+
+    const float4 metallicRoughnessMap = metallicRoughnessTexture.Sample(pbrSampler, input.TexCoord0);
+    const float4 occlusionMap = occlusionTexture.Sample(pbrSampler, input.TexCoord0);
+    const float4 emissiveMap = emissiveTexture.Sample(pbrSampler, input.TexCoord0);
+
+    surface.roughness = clamp(material.metallicRoughnessFactor.y * metallicRoughnessMap.g, 0.01f, 0.99f);
+    surface.metalness = material.metallicRoughnessFactor.x * metallicRoughnessMap.b;
+
+    surface.diffuseColor = color * (1.0f - surface.metalness);
+    surface.specularColor = color * surface.metalness;
+
+    // Constant normal incidence Fresnel factor for all dielectrics.
+    static const float3 dielectricSpec = 0.04f;
+    surface.F0 = lerp(dielectricSpec, color.rgb, surface.metalness);
+
+    // reflectance equation
+    float3 Lo = pbrSurfaceColorIbl(surface);
+
+#if defined(USE_SHADOWS)
+    // Directional light
+    [branch]
+    if (lights.directionalLight.intensity > 0)
+    {
+        Lo += pbrDirectionalLight(lights.directionalLight, surface);
+    }
+
+    // Point lights
+    for (uint i = 0; i < lights.pointLightCount; i++)
+    {
+        PointLight light = pointLights[i];
+        // calculate per-light radiance and add to outgoing radiance Lo
+        Lo += pbrPointLight(light, surface);
+    }
+
+    Lo += (surface.diffuseColor * surface.ao * lights.ambient) + surface.emissive;
+#else
+    Lo += (surface.diffuseColor * surface.ao) + surface.emissive;
+#endif
+
+    return float4(Lo, surface.alpha);
 }

assets/Shaders/ShaderTypes.h

@@ -51,9 +51,14 @@ struct ALIGNMENT PerViewData
 };
 
 /* TODO: pack and use half*/
-struct ALIGNMENT PBRMaterialData
+struct ALIGNMENT PBRMaterialUniforms
 {
     float4 baseColorFactor;
+    float3 emissiveFactor;
+    float _padding;
+    float2 metallicRoughnessFactor;
+    float occlusionStrength;
+    float alphaCutoff;
 };
 
 struct ALIGNMENT InstanceData

samples/Alimer.Samples/Engine/ScenePBRRendererSample.cs

@@ -41,26 +41,13 @@ public ScenePBRRendererSample(IServiceRegistry services)
         };
         MeshAsset meshAsset = meshImporter.Import(meshMetadata).Result;
 
-        Span<VertexPositionNormalTangentTexture> vertices = stackalloc VertexPositionNormalTangentTexture[meshAsset.Data!.VertexCount];
-        for (int i = 0; i < meshAsset.Data.VertexCount; i++)
-        {
-            vertices[i] = new VertexPositionNormalTangentTexture(
-                meshAsset.Data.Positions[i],
-                meshAsset.Data.Normals[i],
-                meshAsset.Data.Tangents[i],
-                meshAsset.Data.Texcoords[i]
-                );
-        }
-
-        Mesh damagedHelmetMesh = new(vertices.Length, VertexPositionNormalTangentTexture.VertexAttributes, meshAsset.Data.Indices!.Length, IndexFormat.Uint32);
-        damagedHelmetMesh.SetVertices(vertices);
-        damagedHelmetMesh.SetIndices(meshAsset.Data.Indices!.AsSpan());
-        damagedHelmetMesh.RecalculateBounds();
-        damagedHelmetMesh.CreateGpuData(GraphicsDevice);
+        Mesh damagedHelmetMesh = meshAsset.Mesh;
         _= ToDispose(damagedHelmetMesh);
 
         {
-            _damagedHelmetEntity = new("Damaged Helmet", new Vector3(0.0f, 2.0f, 0.0f));
+            _damagedHelmetEntity = new("Damaged Helmet", meshAsset.Translation);
+            _damagedHelmetEntity.Transform.Rotation = meshAsset.Rotation;
+            _damagedHelmetEntity.Transform.Scale = meshAsset.Scale;
 
             MeshComponent meshComponent = new(damagedHelmetMesh);
 

samples/Alimer.Samples/Graphics/DrawMeshSample.cs

@@ -14,8 +14,7 @@ namespace Alimer.Samples.Graphics;
 public unsafe sealed class DrawMeshSample : GraphicsSampleBase
 {
     private readonly uint _indexCount;
-    private readonly GraphicsBuffer _vertexBuffer;
-    private readonly GraphicsBuffer _indexBuffer;
+    private readonly Mesh _mesh;
     private readonly GraphicsBuffer _constantBuffer;
     private readonly Texture _texture;
     private readonly Sampler _sampler;
@@ -50,18 +49,7 @@ public DrawMeshSample(IServiceRegistry services, Window mainWindow)
         };
         MeshAsset meshAsset = meshImporter.Import(meshMetadata).Result;
 
-        Span<VertexPositionNormalTexture> vertices = stackalloc VertexPositionNormalTexture[meshAsset.Data!.VertexCount];
-        for (int i = 0; i < meshAsset.Data.VertexCount; i++)
-        {
-            vertices[i] = new VertexPositionNormalTexture(meshAsset.Data.Positions[i], meshAsset.Data.Normals[i], meshAsset.Data.Texcoords[i]);
-        }
-
-        //var data = MeshUtilities.CreateCube(5.0f);
-        //_vertexBuffer = ToDispose(GraphicsDevice.CreateBuffer(data.Vertices, BufferUsage.Vertex));
-        //_indexBuffer = ToDispose(GraphicsDevice.CreateBuffer(data.Indices, BufferUsage.Index));
-        _vertexBuffer = ToDispose(GraphicsDevice.CreateBuffer(vertices, BufferUsage.Vertex));
-        _indexBuffer = ToDispose(GraphicsDevice.CreateBuffer(meshAsset.Data.Indices!.AsSpan(), BufferUsage.Index));
-        _indexCount = (uint)meshAsset.Data!.Indices.Length;
+        _mesh = ToDispose(meshAsset.Mesh);
 
         _constantBuffer = ToDispose(GraphicsDevice.CreateBuffer((ulong)sizeof(Matrix4x4), BufferUsage.Constant, MemoryType.Upload));
 
@@ -131,9 +119,7 @@ public override void Draw(CommandBuffer context, Texture swapChainTexture)
         renderPassEncoder.SetBindGroup(1, _materialBindGroup);
         //context.SetPushConstants(0, worldViewProjection);
 
-        renderPassEncoder.SetVertexBuffer(0, _vertexBuffer);
-        renderPassEncoder.SetIndexBuffer(_indexBuffer, IndexFormat.Uint16);
-        renderPassEncoder.DrawIndexed(_indexCount);
+        _mesh.Draw(renderPassEncoder, 1u);
         renderPassEncoder.EndEncoding();
     }
 }

samples/Alimer.Samples/SampleBrowserGame.cs

@@ -77,7 +77,7 @@ public static void Main()
         GraphicsBackend preferredGraphicsBackend = GraphicsBackend.Default;
 
 #if !WINDOWS
-        preferredGraphicsBackend = GraphicsBackend.Vulkan;
+        //preferredGraphicsBackend = GraphicsBackend.Vulkan;
         //preferredGraphicsBackend = GraphicsBackend.Metal;
 #endif
 

src/Alimer.SourceGenerators/AlimerTypes.cs

@@ -6,6 +6,7 @@ namespace Alimer.SourceGenerators;
 internal static class AlimerTypes
 {
     public const string Engine = "Alimer.Engine";
+    public const string ExposeAttribute = $"Alimer.ExposeAttribute";
     public const string DefaultEntitySystemAttribute = $"{Engine}.DefaultEntitySystemAttribute";
 
     public const string AssetType = $"{Engine}.AssetType";

src/Alimer.SourceGenerators/Extensions.cs

@@ -19,11 +19,11 @@ public static string AsString(this Accessibility accessibility)
             _ => "public"
         };
 
-    public static bool IsStruct(this SyntaxNode node)
-        => node is StructDeclarationSyntax;
+    public static bool IsStruct(this SyntaxNode node) => node is StructDeclarationSyntax;
 
-    public static bool IsClass(this SyntaxNode node)
-        => node is ClassDeclarationSyntax;
+    public static bool IsClass(this SyntaxNode node) => node is ClassDeclarationSyntax;
+
+    public static bool IsEnum(this SyntaxNode node) => node is EnumDeclarationSyntax;
 
     public static bool IsRecordStruct(this SyntaxNode node)
         => node is RecordDeclarationSyntax recordDecl && recordDecl.ClassOrStructKeyword.IsKind(SyntaxKind.StructKeyword);

src/Alimer.SourceGenerators/SerializationGenerator.cs

@@ -14,7 +14,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         IncrementalValuesProvider<ComponentType> classDeclarations = context.SyntaxProvider.ForAttributeWithMetadataName(
            fullyQualifiedMetadataName: AlimerTypes.DefaultEntitySystemAttribute,
-           predicate: static (node, _) => node.IsClass() && node.IsPartial(),
+           predicate: static (node, _) => node.IsPartial() && (node.IsClass() || node.IsStruct() || node.IsEnum()),
            transform: static (context, token) =>
            {
                INamedTypeSymbol classSymbol = (INamedTypeSymbol)context.TargetSymbol;