Added RefCounting, added ConstantBuffers

GlitchyEngine/src/Platform/DX11/Renderer/Dx11ConstantBuffer.bf

@@ -0,0 +1,77 @@
+using DirectX.Common;
+using DirectX.D3D11Shader;
+using System;
+
+using internal GlitchyEngine.Renderer;
+
+namespace GlitchyEngine.Renderer
+{
+	extension BufferVariable
+	{
+		internal this(ConstantBuffer constantBuffer, ID3D11ShaderReflectionVariable* variableReflection)
+		{
+			_constantBuffer = constantBuffer..AddRef();
+
+			HResult result = variableReflection.GetDescription(let variableDescription);
+			Log.EngineLogger.Assert(result.Succeeded, scope $"Failed to get variable description. Error({(int)result}): {result}");
+
+			_name = new String(variableDescription.Name);
+
+			_offset = variableDescription.StartOffset;
+			_sizeInBytes = variableDescription.Size;
+			_isUsed = variableDescription.uFlags.HasFlag(.Used);
+
+			let variableType = variableReflection.GetVariableType();
+			result = variableType.GetDescription(let shaderTypeDescription);
+			Log.EngineLogger.Assert(result.Succeeded, scope $"Failed to get variable type description. Error({(int)result}): {result}");
+
+			switch(shaderTypeDescription.Type)
+			{
+			case .Float:
+				_type = .Float;
+			default:
+				Log.EngineLogger.Assert(false, scope $"Unhandled shader variable type: {shaderTypeDescription.Type}");
+			}
+
+			_columns = shaderTypeDescription.Columns;
+			_rows = shaderTypeDescription.Rows;
+
+			SetRawData(variableDescription.DefaultValue);
+		}
+	}
+
+	extension ConstantBuffer
+	{
+		internal this(GraphicsContext context, ID3D11ShaderReflectionConstantBuffer* bufferReflection) : base(context)
+		{
+			Reflect(bufferReflection);
+
+			ConstructBuffer();
+			
+			Update();
+		}
+
+		private void Reflect(ID3D11ShaderReflectionConstantBuffer* bufferReflection)
+		{
+			HResult result = bufferReflection.GetDescription(let bufferDescription);
+			Log.EngineLogger.Assert(result.Succeeded, scope $"Failed to get buffer description. Error({(int)result}): {result}");
+
+			Log.EngineLogger.AssertDebug(bufferDescription.Type == .D3D_CT_CBUFFER, "The buffer is not of type \"D3D_CT_CBUFFER\"");
+
+			_name = new String(bufferDescription.Name);
+
+			rawData = new uint8[bufferDescription.Size];
+
+			// Flags seem to be irrelevant for us here
+			
+			for(uint32 v = 0; v < bufferDescription.Variables; v++)
+			{
+				ID3D11ShaderReflectionVariable* variableReflection = bufferReflection.GetVariableByIndex(v);
+
+				BufferVariable variable = new BufferVariable(this, variableReflection);
+
+				AddVariable(variable);
+			}
+		}
+	}
+}

GlitchyEngine/src/Platform/DX11/Renderer/Dx11Effect.bf

@@ -0,0 +1,25 @@
+using System;
+using DirectX;
+using DirectX.D3D11;
+
+using internal GlitchyEngine.Renderer;
+
+namespace GlitchyEngine.Renderer
+{
+	extension Effect
+	{
+		protected override void Compile(String vsPath, String vsEntry, String psPath, String psEntry)
+		{
+			// Todo: macros
+			VertexShader = new VertexShader(_context, vsPath, vsEntry);
+			PixelShader = new PixelShader(_context, psPath, psEntry);
+
+			Reflect();
+		}
+
+		private void Reflect()
+		{
+
+		}
+	}
+}

GlitchyEngine/src/Platform/DX11/Renderer/Dx11PixelShader.bf

@@ -12,17 +12,15 @@ namespace GlitchyEngine.Renderer
 
 		public override void CompileFromSource(String code, String entryPoint, ShaderDefine[] macros = null)
 		{
-			Shader.PlattformCompileShaderFromSource(code, macros, entryPoint, "ps_5_0", DefaultCompileFlags, let shaderBlob);
+			Shader.PlattformCompileShaderFromSource(code, macros, entryPoint, "ps_5_0", DefaultCompileFlags, out nativeCode);
 
-			var result = _context.nativeDevice.CreatePixelShader(shaderBlob.GetBufferPointer(), shaderBlob.GetBufferSize(), null, &nativeShader);
+			var result = _context.nativeDevice.CreatePixelShader(nativeCode.GetBufferPointer(), nativeCode.GetBufferSize(), null, &nativeShader);
 			if(result.Failed)
 			{
 				Log.EngineLogger.Error($"Failed to create pixel shader: Message ({(int)result}): {result}");
 			}
 
-			Reflect(shaderBlob);
-			
-			shaderBlob?.Release();
+			Reflect(nativeCode);
 		}
 	}
 }

GlitchyEngine/src/Platform/DX11/Renderer/Dx11Shader.bf

@@ -11,6 +11,11 @@ namespace GlitchyEngine.Renderer
 {
 	extension Shader
 	{
+		/**
+		 * Internal compiled code of the shader.
+		 */
+		internal ID3DBlob* nativeCode ~ _?.Release();
+
 		protected const ShaderCompileFlags DefaultCompileFlags =
 #if DEBUG
 			.Debug;
@@ -62,6 +67,18 @@ namespace GlitchyEngine.Renderer
 				
 				bufferReflection.GetDescription(let bufferDesc);
 
+				// ConstantBuffer
+				if(bufferDesc.Type == .D3D11_CT_CBUFFER)
+				{
+					let buffer = new ConstantBuffer(_context, bufferReflection);
+
+					_buffers.Add(bindDesc.BindPoint, buffer.Name, buffer);
+
+					buffer.ReleaseRef();
+				}
+				/*
+				bufferReflection.GetDescription(let bufferDesc);
+
 				// ConstantBuffer
 				if(bufferDesc.Type == .D3D11_CT_CBUFFER)
 				{
@@ -69,7 +86,8 @@ namespace GlitchyEngine.Renderer
 
 					let buffer = new Buffer(_context, cBufferDesc);
 
-					_buffers.Add(bindDesc.BindPoint, StringView(bufferDesc.Name), buffer, true);
+					_buffers.Add(bindDesc.BindPoint, StringView(bufferDesc.Name), buffer);//, true
+					buffer.ReleaseRef();
 
 					// Buffer for default values
 					uint8* rawData = new:ScopedAlloc! uint8[bufferDesc.Size]*;
@@ -87,6 +105,7 @@ namespace GlitchyEngine.Renderer
 
 					buffer.SetData(Span<uint8>(rawData, bufferDesc.Size));
 				}
+				*/
 			}
 			reflection.Release();
 		}

GlitchyEngine/src/Platform/DX11/Renderer/Dx11VertexShader.bf

@@ -12,8 +12,6 @@ namespace GlitchyEngine.Renderer
 	{
 		internal ID3D11VertexShader* nativeShader ~ _?.Release();
 
-		internal ID3DBlob* nativeCode ~ _?.Release();
-
 		public override void CompileFromSource(String code, String entryPoint, ShaderDefine[] macros = null)
 		{
 			Shader.PlattformCompileShaderFromSource(code, macros, entryPoint, "vs_5_0", DefaultCompileFlags, out nativeCode);