Working on arch, added jolt and entt

Shaders/Tonemap.hlsl

@@ -19,6 +19,13 @@ void main(uint3 threadId : SV_DispatchThreadID)
 		return;
 	}
 
-	// TODO: Fix pixel addressing, black line on right and bottom
-	LDRTexture[threadId.xy] = HDRTexture[threadId.xy];
+	const float gamma = 2.2;
+
+	const float3 hdr_color = HDRTexture[threadId.xy];
+
+	// Reinhard
+	const float3 ldr_color = 1.0f - exp(-hdr_color * exposure);
+	const float3 ldr_gamma_corrected_color = pow(ldr_color, 1.0f / gamma);
+
+	LDRTexture[threadId.xy] = float4(ldr_gamma_corrected_color, 0.0);
 }

Yasno/Graphics/Material.cpp

@@ -1,4 +1,4 @@
-#pragma once
+#include "Material.hpp"
 
 namespace ysn
 {

Yasno/Graphics/Material.hpp

@@ -2,5 +2,7 @@
 
 namespace ysn
 {
-
+	class Material
+	{
+	};
 }

Yasno/Graphics/Mesh.cpp

@@ -1 +1,5 @@
 #include "Mesh.hpp"
+
+namespace ysn
+{
+}

Yasno/Graphics/Mesh.hpp

@@ -1,5 +1,8 @@
 #pragma once
 
-class Mesh
+namespace ysn
 {
-};
+	class Mesh
+	{
+	};
+}

Yasno/Graphics/Primitives.hpp

@@ -2,15 +2,19 @@
 
 namespace ysn
 {
-	struct Sphere
+	class Primitive
 	{
 	};
 
-	struct Box
+	class Sphere
 	{
 	};
 
-	struct Plane
+	class Box
+	{
+	};
+
+	class Plane
 	{
 	};
 }

Yasno/RHI/ColorBuffer.cpp

@@ -0,0 +1,6 @@
+#include "ColorBuffer.hpp"
+
+namespace ysn
+{
+
+}

Yasno/RHI/ColorBuffer.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <d3dx12.h>
+#include <wil/com.h>
+
+namespace ysn
+{
+    class ColorBuffer
+    {
+    public:
+
+    private:
+    };
+}

Yasno/RHI/DepthBuffer.cpp

@@ -0,0 +1,5 @@
+#include "DepthBuffer.hpp"
+
+namespace ysn
+{
+}

Yasno/RHI/DepthBuffer.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <d3dx12.h>
+#include <wil/com.h>
+
+namespace ysn
+{
+    class DepthBuffer
+    {
+    public:
+
+    private:
+    };
+}

Yasno/RHI/GpuBuffer.cpp

@@ -0,0 +1,6 @@
+#include "GpuBuffer.hpp"
+
+namespace ysn
+{
+
+}

Yasno/RHI/GpuBuffer.hpp

@@ -1,6 +1,15 @@
 #pragma once
 
+#include <d3dx12.h>
+#include <wil/com.h>
+
 namespace ysn
 {
-
+    class GpuBuffer
+    {
+    public:
+
+    private:
+        wil::com_ptr<ID3D12Resource> m_resource;
+    };
 }

Yasno/RHI/GpuReadBackBuffer.cpp

@@ -0,0 +1,5 @@
+#include "GpuReadbackBuffer.hpp"
+
+namespace ysn
+{
+}

Yasno/RHI/GpuReadBackBuffer.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <d3dx12.h>
+#include <wil/com.h>
+
+namespace ysn
+{
+    class GpuReadbackBuffer
+    {
+    public:
+
+    private:
+    };
+}

Yasno/RHI/GpuResource.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <d3dx12.h>
+#include <wil/com.h>
+
+namespace ysn
+{
+    class GpuResource
+    {
+    public:
+
+    private:
+        wil::com_ptr<ID3D12Resource> m_resource;
+    };
+}

Yasno/RHI/GpuUploadBuffer.cpp

@@ -0,0 +1,5 @@
+#include "GpuUploadBuffer.hpp"
+
+namespace ysn
+{
+}

Yasno/RHI/GpuUploadBuffer.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <d3dx12.h>
+#include <wil/com.h>
+
+namespace ysn
+{
+    class GpuUploadBuffer
+    {
+    public:
+
+    private:
+    };
+}

Yasno/RHI/PipelineStateObject.hpp

@@ -1,15 +1,32 @@
 #pragma once
 
+#include <string>
+
 #include <d3d12.h>
 #include <wil/com.h>
 
 namespace ysn
 {
 	using PipelineStateObjectId = uint64_t;
 
-	struct PipelineStateObject
+	class PipelineStateObject
+	{
+	public:
+		PipelineStateObject(const std::wstring_view name) : m_name(name) {}
+
+	private:
+		const std::wstring	m_name = L"Unnamed PSO";
+
+		ID3D12RootSignature* m_root_signature = nullptr;
+		ID3D12PipelineState* m_pso = nullptr;
+	};
+
+	class GraphicsPipelineStateObject : public PipelineStateObject
+	{
+	};
+
+	class ComputePipelineStateObject : public PipelineStateObject
 	{
-		wil::com_ptr<ID3D12PipelineState> pso;
 	};
 
 	class PipelineStateObjectManager

Yasno/RHI/PixelBuffer.cpp

@@ -0,0 +1,5 @@
+#include "PixelBuffer.hpp"
+
+namespace ysn
+{
+}

Yasno/RHI/PixelBuffer.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <d3dx12.h>
+#include <wil/com.h>
+
+namespace ysn
+{
+    class PixelBuffer
+    {
+    public:
+
+    private:
+    };
+}

Yasno/RHI/RootSignature.cpp

@@ -0,0 +1,5 @@
+#include "RootSignature.hpp"
+
+namespace ysn
+{
+}

Yasno/RHI/RootSignature.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <d3dx12.h>
+
+namespace ysn
+{
+    class RootSignature
+    {
+    public:
+
+    private:
+    };
+}

Yasno/RHI/ShadowBuffer.cpp

@@ -0,0 +1,5 @@
+#include "ShadowBuffer.hpp"
+
+namespace ysn
+{
+}

Yasno/RHI/ShadowBuffer.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <d3dx12.h>
+#include <wil/com.h>
+
+namespace ysn
+{
+    class ShadowBuffer
+    {
+    public:
+
+    private:
+    };
+}

Yasno/System/Hash.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <System/Math.hpp>
+
+// This requires SSE4.2 which is present on Intel Nehalem (Nov. 2008)
+// and AMD Bulldozer (Oct. 2011) processors.  I could put a runtime
+// check for this, but I'm just going to assume people playing with
+// DirectX 12 on Windows 10 have fairly recent machines.
+#ifdef _M_X64
+#define ENABLE_SSE_CRC32 1
+#else
+#define ENABLE_SSE_CRC32 0
+#endif
+
+#if ENABLE_SSE_CRC32
+#pragma intrinsic(_mm_crc32_u32)
+#pragma intrinsic(_mm_crc32_u64)
+#endif
+
+namespace ysn
+{
+    inline size_t HashRange(const uint32_t* const Begin, const uint32_t* const End, size_t Hash)
+    {
+    #if ENABLE_SSE_CRC32
+        const uint64_t* Iter64 = (const uint64_t*)AlignUp(Begin, 8);
+        const uint64_t* const End64 = (const uint64_t* const)AlignDown(End, 8);
+
+        // If not 64-bit aligned, start with a single u32
+        if ((uint32_t*)Iter64 > Begin)
+            Hash = _mm_crc32_u32((uint32_t)Hash, *Begin);
+
+        // Iterate over consecutive u64 values
+        while (Iter64 < End64)
+            Hash = _mm_crc32_u64((uint64_t)Hash, *Iter64++);
+
+        // If there is a 32-bit remainder, accumulate that
+        if ((uint32_t*)Iter64 < End)
+            Hash = _mm_crc32_u32((uint32_t)Hash, *(uint32_t*)Iter64);
+    #else
+        // An inexpensive hash for CPUs lacking SSE4.2
+        for (const uint32_t* Iter = Begin; Iter < End; ++Iter)
+            Hash = 16777619U * Hash ^ *Iter;
+    #endif
+
+        return Hash;
+    }
+
+    template <typename T> inline size_t HashState( const T* StateDesc, size_t Count = 1, size_t Hash = 2166136261U )
+    {
+        static_assert((sizeof(T) & 3) == 0 && alignof(T) >= 4, "State object is not word-aligned");
+        return HashRange((uint32_t*)StateDesc, (uint32_t*)(StateDesc + Count), Hash);
+    }
+}