[Rendering] Fixes to Shaders, Materials, and SDL GPU;

Author: LittleCodingFox

Engine/Staple.Core/Rendering/Lighting/LightSystem.cs

@@ -165,14 +165,17 @@ public void Submit()
     /// <param name="lighting">The lighting type</param>
     public void ApplyMaterialLighting(Material material, MaterialLighting lighting)
     {
-        if(Enabled == false)
+        if(Enabled == false || true) //TODO
         {
             material.DisableShaderKeyword(Shader.LitKeyword);
             material.DisableShaderKeyword(Shader.HalfLambertKeyword);
 
             return;
         }
 
+        //TODO
+        return;
+
         switch (lighting)
         {
             case MaterialLighting.Lit:
@@ -214,6 +217,9 @@ public void ApplyLightProperties(Material material, Vector3 cameraPosition,
             return;
         }
 
+        //TODO
+        return;
+
         var targets = Lights;
 
         var lightCount = targets.Length;

Engine/Staple.Core/Rendering/Material.cs

@@ -1123,7 +1123,8 @@ internal void ApplyProperties(ApplyMode applyMode, ref RenderState state)
         foreach (var parameter in parameters.Values)
         {
             if((applyMode == ApplyMode.IgnoreTextures && parameter.type == MaterialParameterType.Texture) ||
-                (applyMode == ApplyMode.TexturesOnly && parameter.type != MaterialParameterType.Texture))
+                (applyMode == ApplyMode.TexturesOnly && parameter.type != MaterialParameterType.Texture) ||
+                parameter.shaderHandle.IsValid == false)
             {
                 continue;
             }
@@ -1144,25 +1145,25 @@ internal void ApplyProperties(ApplyMode applyMode, ref RenderState state)
 
                 case MaterialParameterType.Float:
 
-                    shader.SetVector4(ShaderVariantKey, parameter.shaderHandle, new Vector4(parameter.floatValue, 0, 0, 0));
+                    shader.SetFloat(ShaderVariantKey, parameter.shaderHandle, parameter.floatValue);
 
                     break;
 
                 case MaterialParameterType.Int:
 
-                    shader.SetVector4(ShaderVariantKey, parameter.shaderHandle, new Vector4(parameter.intValue, 0, 0, 0));
+                    shader.SetFloat(ShaderVariantKey, parameter.shaderHandle, (float)parameter.intValue);
 
                     break;
 
                 case MaterialParameterType.Vector2:
 
-                    shader.SetVector4(ShaderVariantKey, parameter.shaderHandle, new Vector4(parameter.vector2Value, 0, 0));
+                    shader.SetVector2(ShaderVariantKey, parameter.shaderHandle, parameter.vector2Value);
 
                     break;
 
                 case MaterialParameterType.Vector3:
 
-                    shader.SetVector4(ShaderVariantKey, parameter.shaderHandle, new Vector4(parameter.vector3Value, 0));
+                    shader.SetVector3(ShaderVariantKey, parameter.shaderHandle, parameter.vector3Value);
 
                     break;
 

Engine/Staple.Core/Rendering/RenderSystem/Backend/Impls/SDLGPU/Commands/SDLGPUBeginRenderPassCommand.cs

@@ -21,15 +21,15 @@ public void Update(IRendererBackend rendererBackend)
             return;
         }
 
+        backend.FinishPasses();
+
         backend.viewData.renderTarget = target;
         backend.viewData.clearMode = clearMode;
         backend.viewData.clearColor = clearColor;
         backend.viewData.viewport = viewport;
         backend.viewData.renderData.view = view;
         backend.viewData.renderData.projection = projection;
 
-        backend.FinishPasses();
-
         var texture = nint.Zero;
         var width = 0;
         var height = 0;

Engine/Staple.Core/Rendering/RenderSystem/Backend/Impls/SDLGPU/SDLGPURendererBackend.cs

@@ -1062,7 +1062,9 @@ instance.program is not SDLGPUShaderProgram shader ||
 
                     if (attributeIndex < 0)
                     {
-                        continue;
+                        Log.Error($"Failed to render: vertex attribute {shader.vertexAttributes[i]} was not declared in the vertex layout!");
+
+                        return false;
                     }
 
                     shaderAttributes.Add(new()

Engine/Staple.Core/Rendering/Shader/Shader.cs

@@ -2,9 +2,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
-using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace Staple.Internal;
 
@@ -182,11 +182,7 @@ private static string NormalizeUniformName(string name, ShaderUniformType type)
             name = name.Replace(uniformCountRegex.Match(name).Value, string.Empty);
         }
 
-        return type switch
-        {
-            ShaderUniformType.Int or ShaderUniformType.Float or ShaderUniformType.Vector2 or ShaderUniformType.Vector3 => $"{name}_uniform",
-            _ => name
-        };
+        return name;
     }
 
     private static int NormalizeUniformCount(string name)
@@ -376,6 +372,13 @@ internal bool TryGetUniformData(string variantKey, ShaderHandle handle, out Unif
         return vertexData != null || fragmentData != null;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal static bool CanStoreUniformData(byte[] array, int offset, int size)
+    {
+        //Logic: If we have an array of 1 element, 0 + 1 < 1 fails, so must be <=
+        return offset >= 0 && offset + size <= array.Length;
+    }
+
     private void SetValue<T>(string variantKey, ShaderHandle handle, T value) where T: unmanaged
     {
         if (TryGetUniformData(variantKey, handle, out var uniform, out var offset, out var vertexData, out var fragmentData) == false)
@@ -389,14 +392,14 @@ private void SetValue<T>(string variantKey, ShaderHandle handle, T value) where
         {
             var source = new Span<byte>(&value, size);
 
-            if (vertexData != null && vertexData.Length == size)
+            if (vertexData != null && CanStoreUniformData(vertexData, offset, size))
             {
                 var target = new Span<byte>(vertexData, offset, size);
 
                 source.CopyTo(target);
             }
 
-            if (fragmentData != null && fragmentData.Length == size)
+            if (fragmentData != null && CanStoreUniformData(fragmentData, offset, size))
             {
                 var target = new Span<byte>(fragmentData, offset, size);
 
@@ -420,14 +423,14 @@ private void SetValue<T>(string variantKey, ShaderHandle handle, ReadOnlySpan<T>
                 var size = Marshal.SizeOf<T>() * count;
                 var source = new Span<byte>(ptr, size);
 
-                if (vertexData != null && vertexData.Length >= size && vertexData.Length % size == 0)
+                if (vertexData != null && CanStoreUniformData(vertexData, offset, size))
                 {
                     var target = new Span<byte>(vertexData, offset, size);
 
                     source.CopyTo(target);
                 }
 
-                if (fragmentData != null && fragmentData.Length >= size && fragmentData.Length % size == 0)
+                if (fragmentData != null && CanStoreUniformData(fragmentData, offset, size))
                 {
                     var target = new Span<byte>(fragmentData, offset, size);