Rendering: Working on high level PBR renderer (initial IBL shaders as well)

Author: amerkoleci

Alimer.slnx

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

assets/Shaders/IBL.slang

@@ -0,0 +1,70 @@
+#include "Alimer.hlsli"
+#include "ShaderTypes.h"
+#include "VertexInputOutput.hlsli"
+
+enum class BRDF : uint {
+    Lambert,
+    TrowbridgeReitz,
+};
+
+static float3 CubeDirectionFromFaceAndUV(in int face, in float2 uv)
+{
+    float3 dir;
+    switch (face)
+    {
+    case 0:
+        dir = float3(1.0f, uv.y, -uv.x);
+        break;
+    case 1:
+        dir = float3(-1.0f, uv.y, uv.x);
+        break;
+    case 2:
+        dir = float3(uv.x, -1.0f, uv.y);
+        break;
+    case 3:
+        dir = float3(uv.x, 1.0f, -uv.y);
+        break;
+    case 4:
+        dir = float3(uv.x, uv.y, 1.0f);
+        break;
+    case 5:
+        dir = float3(-uv.x, uv.y, -1.0f);
+        break;
+    }
+
+    return normalize(dir);
+}
+
+static float2 EquirectUVFromCubeDirection(float3 v)
+{
+    const float2 scales = float2(0.1591549f, 0.3183099f);
+    const float2 biases = float2(0.5f, 0.5f);
+    // Assumes +Z is forward. For -X forward, use atan2(v.z, v.x) below instead.
+    float2 uv = float2(atan2(-v.x, v.z), asin(v.y)) * scales + biases;
+    return uv;
+}
+
+// Material (space 0)
+Texture2D<float4> inputTexture : register(t0);
+RWTexture2DArray<float4> outputTexture : register(u0);
+// SamplerState defaultSampler : register(s0);
+
+[shader("compute")]
+[numthreads(32, 32, 1)]
+// Utility kernel for converting from an equirectangular environment map (LDR or HDR) to a cube map
+void CubeFromEquirectangular(uint3 ThreadID: SV_DispatchThreadID)
+{
+    const SamplerState equirectSampler = SamplerLinearClamp;
+    const uint2 coords = ThreadID.xy;
+    const int face = ThreadID.z;
+
+    float outputWidth, outputHeight, outputDepth;
+    outputTexture.GetDimensions(outputWidth, outputHeight, outputDepth);
+
+    const float cubeSize = outputWidth;
+    const float2 cubeUV = ((float2(ThreadID.xy) / (cubeSize - 1)) * 2 - 1);
+    const float3 dir = CubeDirectionFromFaceAndUV(face, cubeUV);
+    const float2 rectUV = EquirectUVFromCubeDirection(dir);
+    float4 color = inputTexture.SampleLevel(equirectSampler, rectUV, 0);
+    outputTexture[uint3(coords, face)] = color;
+}

assets/Shaders/PBR.slang

@@ -2,6 +2,29 @@
 #include "VertexInputOutput.hlsli"
 #include "ShaderTypes.h"
 
+struct SurfaceInfo
+{
+    // Fill these yourself:
+    float3 worldPos; // world space position
+    float3 V;        // normalized vector from the shading location to the eye
+    float3 N;        // surface normal in the world space
+
+    float roughness;
+    float metalness;
+    float3 specularColor;
+    float3 diffuseColor;
+
+    float ao;
+    float alpha;
+    float3 emissive;
+    float4 transmission;
+
+    // Calculated properties
+    float NdotV;
+    float3 R;
+    float3 F0;
+};
+
 // Material (space 0)
 ConstantBuffer<PBRMaterialData> material : register(b0);
 Texture2D<float4> baseColorTexture : register(t0);
@@ -10,10 +33,19 @@ SamplerState baseColorSampler : register(s0);
 [shader("pixel")]
 float4 fragmentMain(in VertexOutput input, in bool isFrontFace: SV_IsFrontFace) : SV_TARGET
 {
-    // Vulkan has issues with static samplers
+    const float4 baseColorMap = baseColorTexture.Sample(baseColorSampler, input.TexCoord0);
+
     // float4 baseColor = material.baseColorFactor * baseColorTexture.Sample(SamplerLinearClamp, input.TexCoord0);
-    float4 baseColor = material.baseColorFactor * baseColorTexture.Sample(baseColorSampler, input.TexCoord0);
+    float4 baseColor = material.baseColorFactor * baseColorMap;
     baseColor.rgb *= input.Color;
+    // clip(baseColor.a - material.GetAlphaCutoff());
+
+    SurfaceInfo surface;
+    surface.worldPos = input.WorldPosition;
+    surface.V = normalize(view.cameraPosition.xyz - surface.worldPos);
+
+    // Should we normalize here?
+    float3x3 TBN = float3x3(input.Tangent, input.Bitangent, input.Normal);
 
     return baseColor;
 }

assets/Shaders/ShaderTypes.h

@@ -50,6 +50,7 @@ struct ALIGNMENT PerViewData
     float3 cameraPosition;
 };
 
+/* TODO: pack and use half*/
 struct ALIGNMENT PBRMaterialData
 {
     float4 baseColorFactor;

assets/Shaders/VertexCommon.slang

@@ -27,8 +27,8 @@ VertexOutput vertexMain(in VertexInput input,
     output.Normal = normalize(mul(float4(input.Normal, 0.0f), worldMatrix)).xyz;
 
     // World-space tangent and bitangent
-    //output.Tangent = normalize(mul(draw.worldMatrix, float4(input.Tangent.xyz, 0.0f))).xyz;
-    //output.Bitangent = cross(output.Normal, output.Tangent) * input.Tangent.w;
+    output.Tangent = normalize(mul(float4(input.Tangent.xyz, 0.0f), worldMatrix)).xyz;
+    output.Bitangent = cross(output.Normal, output.Tangent) * input.Tangent.w;
 
     // Pass along the texture coordinates
     output.TexCoord0 = input.TexCoord0;

assets/Shaders/VertexInputOutput.hlsli

@@ -11,8 +11,8 @@
 struct VertexInput {
     float3 Position : POSITION;
     float3 Normal : NORMAL;
+    float4 Tangent : TANGENT;
     float2 TexCoord0 : TEXCOORD0;
-    //float4 Tangent : TANGENT;
     //float2 TexCoord1 : TEXCOORD1;
 
 #if USE_VERTEX_COLOR

samples/Alimer.Samples/Assets/Shaders/PBR.slang

@@ -0,0 +1,24 @@
+#include "Alimer.hlsli"
+#include "VertexInputOutput.hlsli"
+#include "ShaderTypes.h"
+
+// Material (space 0)
+ConstantBuffer<PBRMaterialData> material : register(b0);
+Texture2D<float4> baseColorTexture : register(t0);
+SamplerState baseColorSampler : register(s0);
+
+[shader("pixel")]
+float4 fragmentMain(in VertexOutput input, in bool isFrontFace: SV_IsFrontFace) : SV_TARGET
+{
+    SurfaceInfo surface;
+    surface.worldPos = input.WorldPosition;
+    surface.V = normalize(view.cameraPosition.xyz - surface.worldPos);
+
+    const float4 baseColorMap = baseColorTexture.Sample(baseColorSampler, input.TexCoord0);
+
+    // float4 baseColor = material.baseColorFactor * baseColorTexture.Sample(SamplerLinearClamp, input.TexCoord0);
+    float4 baseColor = material.baseColorFactor * baseColorMap;
+    baseColor.rgb *= input.Color;
+
+    return baseColor;
+}

samples/Alimer.Samples/Engine/ScenePBRRendererSample.cs

@@ -0,0 +1,93 @@
+// Copyright (c) Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.ComponentModel;
+using System.Numerics;
+using Alimer.Assets.Graphics;
+using Alimer.Engine;
+using Alimer.Graphics;
+using Alimer.Physics;
+using Alimer.Rendering;
+
+namespace Alimer.Samples;
+
+[Description("Engine - Scene PBR Renderer")]
+public sealed class ScenePBRRendererSample : SampleBase
+{
+    private readonly Entity _cameraEntity;
+    private readonly Entity _damagedHelmetEntity;
+
+    public ScenePBRRendererSample(IServiceRegistry services)
+        : base("Engine - Scene Cube")
+    {
+        Services = services;
+        GraphicsDevice = services.GetService<GraphicsDevice>();
+        Scene = services.GetService<SceneSystem>();
+        Entity root = new();
+
+        // Camera
+        _cameraEntity = new();
+        CameraComponent camera = _cameraEntity.AddComponent<CameraComponent>();
+        camera.Entity!.Transform.Position = new Vector3(0.0f, 0.0f, 25.0f);
+        root.Children.Add(_cameraEntity);
+
+        // GLTF mesh
+        PhysicallyBasedMaterial sharedMaterial = new()
+        {
+            BaseColorFactor = Colors.White,
+        };
+
+        string meshesPath = Path.Combine(AppContext.BaseDirectory, "Assets", "Meshes");
+
+        MeshImporter meshImporter = new();
+        MeshMetadata meshMetadata = new()
+        {
+            FileFullPath = Path.Combine(meshesPath, "DamagedHelmet.glb")
+        };
+        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);
+        _= ToDispose(damagedHelmetMesh);
+
+        {
+            _damagedHelmetEntity = new("Damaged Helmet", new Vector3(0.0f, 2.0f, 0.0f));
+
+            MeshComponent meshComponent = new(damagedHelmetMesh);
+            meshComponent.Materials.Add(sharedMaterial);
+            _damagedHelmetEntity.AddComponent(meshComponent);
+            root.Children.Add(_damagedHelmetEntity);
+        }
+
+        Scene.RootEntity = root;
+    }
+
+    public IServiceRegistry Services { get; }
+    public GraphicsDevice GraphicsDevice { get; }
+    public SceneSystem Scene { get; }
+
+    public override void Update(GameTime time)
+    {
+        float deltaTime = (float)time.Elapsed.TotalSeconds;
+        _damagedHelmetEntity.Transform.Rotate(10 * deltaTime, 20 * deltaTime, 30 * deltaTime);
+    }
+
+    public override void Draw(CommandBuffer context, Texture swapChainTexture)
+    {
+        //_cubeEntity.GetComponent<RigidBodyComponent>().LinearVelocity = new Vector3(100, -100.0f, 0.0f);
+    }
+}

samples/Alimer.Samples/Graphics/DrawIndexedQuadSample.cs

@@ -64,7 +64,7 @@ public override void Draw(CommandBuffer context, Texture swapChainTexture)
 
         RenderPassEncoder renderPassEncoder = context.BeginRenderPass(backBufferRenderPass);
         renderPassEncoder.SetVertexBuffer(0, _vertexBuffer);
-        renderPassEncoder.SetIndexBuffer(_indexBuffer, IndexFormat.UInt16);
+        renderPassEncoder.SetIndexBuffer(_indexBuffer, IndexFormat.Uint16);
         renderPassEncoder.SetPipeline(_renderPipeline!);
         renderPassEncoder.DrawIndexed(6);
         renderPassEncoder.EndEncoding();

samples/Alimer.Samples/Graphics/DrawMeshSample.cs

@@ -132,7 +132,7 @@ public override void Draw(CommandBuffer context, Texture swapChainTexture)
         //context.SetPushConstants(0, worldViewProjection);
 
         renderPassEncoder.SetVertexBuffer(0, _vertexBuffer);
-        renderPassEncoder.SetIndexBuffer(_indexBuffer, IndexFormat.UInt16);
+        renderPassEncoder.SetIndexBuffer(_indexBuffer, IndexFormat.Uint16);
         renderPassEncoder.DrawIndexed(_indexCount);
         renderPassEncoder.EndEncoding();
     }