Add normal maps

Resources/EnginePrototypes/Shaders/stockshaders.yml

@@ -17,3 +17,8 @@
   id: ColorPicker
   kind: source
   path: "/Shaders/color_picker.swsl"
+
+- type: shader
+  id: NormalRotator
+  kind: source
+  path: "/Shaders/Internal/normal-rotator.swsl"

Resources/Shaders/Internal/color.swsl

@@ -0,0 +1,5 @@
+uniform highp vec4 InputColor;
+
+void fragment() {
+    COLOR = InputColor;
+}

Resources/Shaders/Internal/light_shared.swsl

@@ -2,20 +2,27 @@ preset raw;
 
 #include "/Shaders/Internal/shadow_cast_shared.swsl"
 
-const highp float LIGHTING_HEIGHT = 1.0;
-
 const highp float g_MinVariance = 0.0;
 
+const highp float COLOR_POWER = 0.452;
+
 varying highp vec2 worldPosition;
 
 uniform highp vec4 lightColor;
 // Position of the light, in world coordinates.
 uniform highp vec2 lightCenter;
+uniform highp float lightHeight;
+uniform highp vec2 eyeCenter;
+uniform highp vec2 eyeZoom;
 uniform highp float lightRange;
 uniform highp float lightPower;
 uniform highp float lightSoftness;
 uniform highp float lightIndex;
+uniform highp int useNormals;
+uniform highp float globalRotation;
+uniform highp float maskRotation;
 uniform sampler2D shadowMap;
+uniform sampler2D normalMap;
 
 void vertex()
 {
@@ -26,6 +33,11 @@ void vertex()
     VERTEX = transformed.xy;
 }
 
+highp vec2 rotateVector(highp vec2 vector, highp float theta)
+{
+    return vector * cos(theta) + vector.yx * vec2(-1, 1) * sin(theta);
+}
+
 highp float shadowContrib(highp vec2 diff)
 {
     highp float dist = length(diff);
@@ -47,12 +59,34 @@ void fragment()
         discard;
     }
 
-    highp float dist = dot(diff, diff) + LIGHTING_HEIGHT;
+    highp float dist = dot(diff, diff) + abs(lightHeight);
     highp float val = clamp((1.0 - clamp(sqrt(dist) / lightRange, 0.0, 1.0)) * (1.0 / (sqrt(dist + 1.0))), 0.0, 1.0);
 
     val *= lightPower;
     val *= mask;
 
-    COLOR = vec4(lightColor.rgb, val * occlusion);
+    highp float run = 1.0;
+
+    if (useNormals == 1)
+    {
+        highp vec2 lightDir = rotateVector(normalize(diff), globalRotation);
+        highp vec2 newUV = rotateVector(UV - vec2(0.5, 0.5) + rotateVector((lightCenter - eyeCenter) / vec2(2, -2) / lightRange, maskRotation), -globalRotation);
+        newUV *= (projectionMatrix * vec3(1.0, 1.0, 0.0)).xy * vec2(1.0, -1.0) / eyeZoom * lightRange;
+        newUV += vec2(0.5, 0.5);
+
+        highp vec4 origSample = texture2D(normalMap, newUV);
+        if (origSample.xyzw == vec4(0.0, 0.0, 0.0, 1.0))
+            discard;
+
+        // origSample is on the range 0 - 1 in all components,
+        // but every color component has been raised to SOMETHING by some unknown mechanism
+        // so we first raise it to the 0.452nd power to reset it
+        highp vec3 normalSample = pow(origSample.xyz, vec3(COLOR_POWER)) * vec3(2.0, 2.0, 1.0) - vec3(1.0, 1.0, 0.0);
+        run = dot(normalize(vec3(lightDir, lightHeight)), normalSample * vec3(-1.0, -1.0, 1.0));
+        if (run <= 0.0)
+            discard;
+    }
+
+    COLOR = vec4(lightColor.xyz, val * occlusion * run);
 }
 

Resources/Shaders/Internal/normal-rotator.swsl

@@ -0,0 +1,12 @@
+uniform highp float rotation;
+const highp float COLOR_POWER = 0.452;
+const highp float COLOR_POWERNT = 2.212;
+
+void fragment()
+{
+    highp vec4 Col = zTexture(UV);
+    Col = vec4(pow(Col.xy, vec2(COLOR_POWER)) - vec2(0.5, 0.5), Col.zw);
+    Col = vec4(Col.xy * cos(rotation) + vec2(-1.0, 1.0) * Col.yx * sin(rotation), Col.zw);
+    Col = vec4(pow(Col.xy + vec2(0.5, 0.5), vec2(COLOR_POWERNT)), Col.zw);
+    COLOR = Col;
+}

Robust.Client/GameObjects/Components/Renderable/SpriteComponent.cs

@@ -12,6 +12,7 @@
 using Robust.Shared.Animations;
 using Robust.Shared.ComponentTrees;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Graphics;
 using Robust.Shared.Graphics.RSI;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
@@ -58,6 +59,8 @@ public sealed partial class SpriteComponent : Component, IComponentDebug, ISeria
         [DataField("visible")]
         private bool _visible = true;
 
+        private const string NormalShaderPrototype = "NormalRotator";
+
         // VV convenience variable to examine layer objects using layer keys
         [ViewVariables]
         private Dictionary<object, Layer> _mappedLayers => LayerMap.ToDictionary(x => x.Key, x => Layers[x.Value]);
@@ -786,6 +789,9 @@ public void LayerSetData(int index, PrototypeLayerData layerDatum)
                 }
             }
 
+            prototypes.TryIndex<ShaderPrototype>(NormalShaderPrototype, out var normalProto);
+            layer.NormalShader = normalProto!.Instance();
+
             layer.RenderingStrategy = layerDatum.RenderingStrategy ?? layer.RenderingStrategy;
             layer.Cycle = layerDatum.Cycle;
 
@@ -1289,7 +1295,7 @@ public bool SnapCardinals
         [ViewVariables(VVAccess.ReadWrite)]
         public bool NoRotation { get => _screenLock; set => _screenLock = value; }
 
-        internal void RenderInternal(DrawingHandleWorld drawingHandle, Angle eyeRotation, Angle worldRotation, Vector2 worldPosition, Direction? overrideDirection)
+        internal void RenderInternal(DrawingHandleWorld drawingHandle, Angle eyeRotation, Angle worldRotation, Vector2 worldPosition, Direction? overrideDirection, bool normal = false)
         {
             var angle = worldRotation + eyeRotation; // angle on-screen. Used to decide the direction of 4/8 directional RSIs
             angle = angle.Reduced().FlipPositive();  // Reduce the angles to fix math shenanigans
@@ -1324,16 +1330,16 @@ internal void RenderInternal(DrawingHandleWorld drawingHandle, Angle eyeRotation
                     switch (layer.RenderingStrategy)
                     {
                         case LayerRenderingStrategy.NoRotation:
-                            layer.Render(drawingHandle, ref transformNoRot, angle, overrideDirection);
+                            layer.Render(drawingHandle, ref transformNoRot, angle, overrideDirection, (float)eyeRotation, normal: normal);
                             break;
                         case LayerRenderingStrategy.SnapToCardinals:
-                            layer.Render(drawingHandle, ref transformSnap, angle, overrideDirection);
+                            layer.Render(drawingHandle, ref transformSnap, angle, overrideDirection, (float)eyeRotation, normal: normal);
                             break;
                         case LayerRenderingStrategy.Default:
-                            layer.Render(drawingHandle, ref transformDefault, angle, overrideDirection);
+                            layer.Render(drawingHandle, ref transformDefault, angle, overrideDirection, (float)eyeRotation, normal: normal);
                             break;
                         case LayerRenderingStrategy.UseSpriteStrategy:
-                            layer.Render(drawingHandle, ref transformSprite, angle, overrideDirection);
+                            layer.Render(drawingHandle, ref transformSprite, angle, overrideDirection, (float)eyeRotation, normal: normal);
                             break;
                         default:
                             Logger.Error($"Tried to render a layer with unknown rendering stragegy: {layer.RenderingStrategy}");
@@ -1346,7 +1352,7 @@ internal void RenderInternal(DrawingHandleWorld drawingHandle, Angle eyeRotation
             {
                 foreach (var layer in Layers)
                 {
-                    layer.Render(drawingHandle, ref transformSprite, angle, overrideDirection);
+                    layer.Render(drawingHandle, ref transformSprite, angle, overrideDirection, (float)eyeRotation, normal: normal);
                 }
             }
         }
@@ -1492,9 +1498,9 @@ public enum DirectionOffset : byte
         public sealed class Layer : ISpriteLayer, ISerializationHooks
         {
             [ViewVariables] private readonly SpriteComponent _parent;
-
             [ViewVariables] public string? ShaderPrototype;
             [ViewVariables] public ShaderInstance? Shader;
+            /* no vv 4 u */ public ShaderInstance? NormalShader;
             [ViewVariables] public Texture? Texture;
 
             private RSI? _rsi;
@@ -2017,7 +2023,7 @@ public static RsiDirection GetDirection(RsiDirectionType dirType, Angle angle)
             /// <summary>
             ///     Render a layer. This assumes that the input angle is between 0 and 2pi.
             /// </summary>
-            internal void Render(DrawingHandleWorld drawingHandle, ref Matrix3x2 spriteMatrix, Angle angle, Direction? overrideDirection)
+            internal void Render(DrawingHandleWorld drawingHandle, ref Matrix3x2 spriteMatrix, Angle angle, Direction? overrideDirection, float eyeRotation = 0f, bool normal = false)
             {
                 if (!Visible || Blank)
                     return;
@@ -2042,7 +2048,7 @@ internal void Render(DrawingHandleWorld drawingHandle, ref Matrix3x2 spriteMatri
                     var transformMatrix = Matrix3x2.Multiply(layerMatrix, spriteMatrix);
                     drawingHandle.SetTransform(in transformMatrix);
 
-                    RenderTexture(drawingHandle, texture);
+                    RenderTexture(drawingHandle, texture, eyeRotation, normal: normal);
                 }
                 else
                 {
@@ -2072,18 +2078,24 @@ internal void Render(DrawingHandleWorld drawingHandle, ref Matrix3x2 spriteMatri
                 }
             }
 
-            private void RenderTexture(DrawingHandleWorld drawingHandle, Texture texture)
+            private void RenderTexture(DrawingHandleWorld drawingHandle, Texture texture, float textureRotation = 0f, bool normal = false)
             {
-                if (Shader != null)
+                if (normal && NormalShader is {} normalShader)
+                {
+                    NormalShader = normalShader.Mutable ? normalShader : normalShader.Duplicate();
+                    drawingHandle.UseShader(NormalShader);
+                    NormalShader.SetParameter("rotation", textureRotation + (float)drawingHandle.GetTransform().Rotation());
+                }
+                else if (Shader != null)
                     drawingHandle.UseShader(Shader);
 
-                var layerColor = _parent.color * Color;
+                var layerColor = normal ? Color.White : _parent.color * Color;
                 var textureSize = texture.Size / (float)EyeManager.PixelsPerMeter;
                 var quad = Box2.FromDimensions(textureSize/-2, textureSize);
 
-                drawingHandle.DrawTextureRectRegion(texture, quad, layerColor);
+                drawingHandle.DrawTextureRectRegion(texture, quad, layerColor, normal: normal);
 
-                if (Shader != null)
+                if (Shader != null || normal)
                     drawingHandle.UseShader(null);
             }
 

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -46,12 +46,12 @@ public sealed partial class SpriteSystem : EntitySystem
 
         private ISawmill _sawmill = default!;
 
-        internal void Render(EntityUid uid, SpriteComponent sprite, DrawingHandleWorld drawingHandle, Angle eyeRotation, in Angle worldRotation, in Vector2 worldPosition)
+        internal void Render(EntityUid uid, SpriteComponent sprite, DrawingHandleWorld drawingHandle, Angle eyeRotation, in Angle worldRotation, in Vector2 worldPosition, bool normal = false)
         {
             if (!sprite.IsInert)
                 _queuedFrameUpdate.Add(uid);
 
-            sprite.RenderInternal(drawingHandle, eyeRotation, worldRotation, worldPosition, sprite.EnableDirectionOverride ? sprite.DirectionOverride : null);
+            sprite.RenderInternal(drawingHandle, eyeRotation, worldRotation, worldPosition, sprite.EnableDirectionOverride ? sprite.DirectionOverride : null, normal: normal);
         }
 
         public override void Initialize()

Robust.Client/Graphics/AtlasTexture.cs

@@ -12,14 +12,15 @@ namespace Robust.Client.Graphics
     [PublicAPI]
     public sealed class AtlasTexture : Texture
     {
-        public AtlasTexture(Texture texture, UIBox2 subRegion) : base((Vector2i) subRegion.Size)
+        public AtlasTexture(Texture texture, UIBox2 subRegion, int? width = null) : base((Vector2i) subRegion.Size)
         {
             DebugTools.Assert(SubRegion.Right < texture.Width);
             DebugTools.Assert(SubRegion.Bottom < texture.Height);
             DebugTools.Assert(SubRegion.Left >= 0);
             DebugTools.Assert(SubRegion.Top >= 0);
 
             SubRegion = subRegion;
+            RegionWidth = width ?? (int)subRegion.Width;
             SourceTexture = texture;
         }
 
@@ -33,6 +34,11 @@ public AtlasTexture(Texture texture, UIBox2 subRegion) : base((Vector2i) subRegi
         /// </summary>
         public UIBox2 SubRegion { get; }
 
+        /// <summary>
+        ///     The width of the texture we came from, used for offsetting to get normals
+        /// </summary>
+        public int RegionWidth { get; }
+
         public override Color GetPixel(int x, int y)
         {
             DebugTools.Assert(x < SubRegion.Right);

Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using OpenToolkit.Graphics.OpenGL4;
+using Robust.Shared;
+using Robust.Shared.Configuration;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Graphics;
@@ -27,8 +29,14 @@ internal partial class Clyde
 
         private List<Entity<MapGridComponent>> _grids = new();
 
-        private void _drawGrids(Viewport viewport, Box2 worldAABB, Box2Rotated worldBounds, IEye eye)
+        private void _drawGrids(Viewport viewport, Box2 worldAABB, Box2Rotated worldBounds, IEye eye, bool normal = false)
         {
+            if (normal && (!_lightManager.Enabled
+                           || !_lightManager.DrawLighting
+                           || !_cfg.GetCVar(CVars.LightNormals)
+                           || !_resourceCache.GetNormalsEnabled()))
+                return;
+
             var mapId = eye.Position.MapId;
             if (!_mapManager.MapExists(mapId))
             {
@@ -55,12 +63,16 @@ private void _drawGrids(Viewport viewport, Box2 worldAABB, Box2Rotated worldBoun
                 {
                     SetTexture(TextureUnit.Texture0, _tileDefinitionManager.TileTextureAtlas);
                     SetTexture(TextureUnit.Texture1, _lightingReady ? viewport.LightRenderTarget.Texture : _stockTextureWhite);
-                    gridProgram = ActivateShaderInstance(_defaultShader.Handle).Item1;
+
+                    gridProgram = ActivateShaderInstance((normal ? _colorShader : _defaultShader).Handle).Item1;
+                    if (normal)
+                        gridProgram.SetUniformMaybe("InputColor", new Color(0.5f, 0.5f, 1f));
                     SetupGlobalUniformsImmediate(gridProgram, (ClydeTexture) _tileDefinitionManager.TileTextureAtlas);
 
                     gridProgram.SetUniformTextureMaybe(UniIMainTexture, TextureUnit.Texture0);
                     gridProgram.SetUniformTextureMaybe(UniILightTexture, TextureUnit.Texture1);
-                    gridProgram.SetUniform(UniIModUV, new Vector4(0, 0, 1, 1));
+                    if (!normal)
+                        gridProgram.SetUniform(UniIModUV, new Vector4(0, 0, 1, 1));
                 }
 
                 var transform = _entityManager.GetComponent<TransformComponent>(mapGrid);

Robust.Client/Graphics/Clyde/Clyde.HLR.cs

@@ -16,6 +16,7 @@
 using Robust.Shared.Maths;
 using Robust.Shared.Profiling;
 using Robust.Shared.Utility;
+using Color = Robust.Shared.Maths.Color;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -247,8 +248,14 @@ private List<Overlay> GetOverlaysForSpace(OverlaySpace space)
             return ScreenBufferTexture;
         }
 
-        private void DrawEntities(Viewport viewport, Box2Rotated worldBounds, Box2 worldAABB, IEye eye)
+        private void DrawEntities(Viewport viewport, Box2Rotated worldBounds, Box2 worldAABB, IEye eye, bool normal = false)
         {
+            if (normal && (!_lightManager.Enabled
+                           || !_lightManager.DrawLighting
+                           || !_cfg.GetCVar(CVars.LightNormals)
+                           || !_resourceCache.GetNormalsEnabled()))
+                return;
+
             var mapId = eye.Position.MapId;
             if (mapId == MapId.Nullspace)
                 return;
@@ -353,7 +360,13 @@ private void DrawEntities(Viewport viewport, Box2Rotated worldBounds, Box2 world
                     }
                 }
 
-                spriteSystem.Render(entry.Uid, entry.Sprite, _renderHandle.DrawingHandleWorld, eye.Rotation, in entry.WorldRot, in entry.WorldPos);
+                spriteSystem.Render(entry.Uid,
+                    entry.Sprite,
+                    _renderHandle.DrawingHandleWorld,
+                    eye.Rotation,
+                    in entry.WorldRot,
+                    in entry.WorldPos,
+                    normal: normal);
 
                 if (entry.Sprite.PostShader != null && entityPostRenderTarget != null)
                 {
@@ -481,6 +494,19 @@ private void RenderViewport(Viewport viewport)
 
                 if (eye.Position.MapId != MapId.Nullspace)
                 {
+                    // prob not needed
+                    using (DebugGroup("GridNormals"))
+                    using (_prof.Group("GridNormals"))
+                    {
+                        _drawGrids(viewport, worldAABB, worldBounds, eye, normal: true);
+                    }
+
+                    using (DebugGroup("EntityNormals"))
+                    using (_prof.Group("EntityNormals"))
+                    {
+                        DrawEntities(viewport, worldBounds, worldAABB, eye, normal: true);
+                    }
+
                     using (DebugGroup("Lights"))
                     using (_prof.Group("Lights"))
                     {