initial diffuse lit sprite effect

2020-12-05 19:47:01 -08:00 · 2020-12-05 19:47:01 -08:00 · 47242e4f52
parent ae445d94d3
commit 47242e4f52
7 changed files with 293 additions and 11 deletions
--- a/Effects/DiffuseLitSpriteEffect.cs
+++ b/Effects/DiffuseLitSpriteEffect.cs
@ -0,0 +1,154 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Kav
+{
+    public class DiffuseLitSpriteEffect : Effect
+    {
+        EffectParameter textureParam;
+
+        EffectParameter ambientColorParam;
+
+        EffectParameter directionalLightDirectionParam;
+        EffectParameter directionalLightColorParam;
+
+        EffectParameter worldParam;
+        EffectParameter worldViewProjectionParam;
+        EffectParameter worldInverseTransposeParam;
+
+        Texture2D texture;
+
+        Vector3 ambientColor;
+
+        Vector3 directionalLightDirection;
+        Vector3 directionalLightColor;
+
+        Matrix world = Matrix.Identity;
+        Matrix view = Matrix.Identity;
+        Matrix projection = Matrix.Identity;
+
+        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
+
+        public Texture2D Texture
+        {
+            get { return texture; }
+            set
+            {
+                texture = value;
+                textureParam.SetValue(texture);
+            }
+        }
+
+        public Matrix World
+        {
+            get { return world; }
+            set
+            {
+                world = value;
+                dirtyFlags |= EffectDirtyFlags.World | EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+        public Matrix View
+        {
+            get { return view; }
+            set
+            {
+                view = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.EyePosition;
+            }
+        }
+
+        public Matrix Projection
+        {
+            get { return projection; }
+            set
+            {
+                projection = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+        public int MaxPointLights { get; } = 8;
+
+        public Vector3 AmbientColor
+        {
+            get { return ambientColor; }
+            set
+            {
+                ambientColor = value;
+                ambientColorParam.SetValue(ambientColor);
+            }
+        }
+
+        public PointLightCollection PointLights { get; private set; }
+
+        public Vector3 DirectionalLightDirection
+        {
+            get { return directionalLightDirection; }
+            set
+            {
+                directionalLightDirection = value;
+                directionalLightDirectionParam.SetValue(directionalLightDirection);
+            }
+        }
+
+        public Vector3 DirectionalLightColor
+        {
+            get { return directionalLightColor; }
+            set
+            {
+                directionalLightColor = value;
+                directionalLightColorParam.SetValue(directionalLightColor);
+            }
+        }
+
+        public DiffuseLitSpriteEffect(GraphicsDevice graphicsDevice) : base(graphicsDevice, Resources.DiffuseLitSpriteEffect)
+        {
+            CacheEffectParameters();
+
+            PointLights = new PointLightCollection(
+                Parameters["PointLightPositions"],
+                Parameters["PointLightColors"],
+                MaxPointLights
+            );
+        }
+
+        protected override void OnApply()
+        {
+            if ((dirtyFlags & EffectDirtyFlags.World) != 0)
+            {
+                worldParam.SetValue(world);
+
+                Matrix.Invert(ref world, out Matrix worldInverse);
+                Matrix.Transpose(ref worldInverse, out Matrix worldInverseTranspose);
+                worldInverseTransposeParam.SetValue(worldInverseTranspose);
+
+                dirtyFlags &= ~EffectDirtyFlags.World;
+            }
+
+            if ((dirtyFlags & EffectDirtyFlags.WorldViewProj) != 0)
+            {
+                Matrix.Multiply(ref world, ref view, out Matrix worldView);
+                Matrix.Multiply(ref worldView, ref projection, out Matrix worldViewProj);
+                worldViewProjectionParam.SetValue(worldViewProj);
+
+                dirtyFlags &= ~EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+        private void CacheEffectParameters()
+        {
+            textureParam = Parameters["Texture"];
+
+            worldParam = Parameters["World"];
+            worldViewProjectionParam = Parameters["WorldViewProjection"];
+            worldInverseTransposeParam = Parameters["WorldInverseTranspose"];
+
+            ambientColorParam = Parameters["AmbientColor"];
+
+            directionalLightDirectionParam = Parameters["DirectionalLightDirection"];
+            directionalLightColorParam = Parameters["DirectionalLightColor"];
+        }
+    }
+}
--- a/Effects/FXB/DiffuseLitSpriteEffect.fxb
+++ b/Effects/FXB/DiffuseLitSpriteEffect.fxb
--- a/Effects/HLSL/DiffuseLitSprite.fx
+++ b/Effects/HLSL/DiffuseLitSprite.fx
@ -0,0 +1,90 @@
+#include "Macros.fxh" //from FNA
+
+// Effect applies normalmapped lighting to a 2D sprite.
+
+DECLARE_TEXTURE(Texture, 0);
+DECLARE_TEXTURE(Normal, 1);
+
+BEGIN_CONSTANTS
+
+    float AmbientColor                       _ps(c0)    _cb(c0);
+
+    float3 PointLightPositions[8]            _ps(c1)    _cb(c1);
+    float3 PointLightColors[8]               _ps(c9)    _cb(c9);
+
+    float DirectionalLightDirection          _ps(c17)   _cb(c17);
+    float DirectionalLightColor              _ps(c18)   _cb(c18);
+
+MATRIX_CONSTANTS
+
+    float4x4 WorldInverseTranspose           _ps(c19)   _cb(c19);
+    float4x4 World                  _vs(c0)             _cb(c23);
+    float4x4 WorldViewProjection    _vs(c4)             _cb(c27);
+
+END_CONSTANTS
+
+struct VertexShaderInput
+{
+    float4 Position : POSITION;
+    float2 TexCoord : TEXCOORD0;
+};
+
+struct PixelShaderInput
+{
+    float4 Position   : SV_Position;
+    float2 TexCoord   : TEXCOORD0;
+    float3 PositionWS : TEXCOORD2;
+};
+
+PixelShaderInput main_vs(VertexShaderInput input)
+{
+    PixelShaderInput output;
+
+    output.TexCoord = input.TexCoord;
+    output.PositionWS = mul(input.Position, World).xyz;
+    output.Position = mul(input.Position, WorldViewProjection);
+
+    return output;
+}
+
+float4 main_ps(PixelShaderInput input) : COLOR0
+{
+    // Look up the texture and normalmap values.
+    float4 tex = tex2D(TextureSampler, input.TexCoord);
+    float3 normal = tex2D(NormalSampler, input.TexCoord).xyz;
+    float3 normalWS = mul(normal, (float3x3)WorldInverseTranspose).xyz;
+
+    float3 lightColor = float3(0.0, 0.0, 0.0);
+
+    // point lights
+    for (int i = 0; i < 8; i++)
+    {
+        float3 lightVec = PointLightPositions[i] - input.PositionWS;
+        float distance = length(lightVec);
+
+        float3 lightDir = normalize(lightVec);
+        float diffuse = max(dot(normalWS, lightDir), 0.0);
+        float3 attenuation = 1.0 / (distance * distance);
+
+        lightColor += diffuse * attenuation * PointLightColors[i];
+    }
+
+    // directional light
+    float directionalDiffuse = max(dot(normalWS, DirectionalLightDirection), 0.0);
+    lightColor += directionalDiffuse * DirectionalLightColor;
+
+    // ambient light
+    lightColor += AmbientColor;
+
+    // blend with sample
+    return tex * float4(lightColor, 1.0);
+}
+
+Technique DiffuseLitSprite
+{
+    pass
+    {
+        VertexShader = compile vs_3_0 main_vs();
+        PixelShader = compile ps_3_0 main_ps();
+    }
+}
--- a/Kav.Core.csproj
+++ b/Kav.Core.csproj
@ -49,6 +49,9 @@
    <EmbeddedResource Include="Effects\FXB\SkyboxEffect.fxb">
      <LogicalName>Kav.Resources.SkyboxEffect.fxb</LogicalName>
 		</EmbeddedResource>
+    <EmbeddedResource Include="Effects\FXB\DiffuseLitSpriteEffect.fxb">
+      <LogicalName>Kav.Resources.DiffuseLitSpriteEffect.fxb</LogicalName>
+		</EmbeddedResource>
    <EmbeddedResource Include="Models\UnitCube.glb">
      <LogicalName>Kav.Resources.UnitCube.glb</LogicalName>
 		</EmbeddedResource>
--- a/Kav.Framework.csproj
+++ b/Kav.Framework.csproj
@ -49,6 +49,9 @@
    <EmbeddedResource Include="Effects\FXB\SkyboxEffect.fxb">
      <LogicalName>Kav.Resources.SkyboxEffect.fxb</LogicalName>
 		</EmbeddedResource>
+    <EmbeddedResource Include="Effects\FXB\DiffuseLitSpriteEffect.fxb">
+      <LogicalName>Kav.Resources.DiffuseLitSpriteEffect.fxb</LogicalName>
+		</EmbeddedResource>
    <EmbeddedResource Include="Models\UnitCube.glb">
      <LogicalName>Kav.Resources.UnitCube.glb</LogicalName>
 		</EmbeddedResource>
--- a/Renderer.cs
+++ b/Renderer.cs
@ -33,7 +33,7 @@ namespace Kav
        private LinearDepthEffect LinearDepthEffect { get; }
        private Effect ToneMapEffect { get; }
        private SkyboxEffect SkyboxEffect { get; }
-        private BasicEffect BasicEffect { get; }
+        private DiffuseLitSpriteEffect DiffuseLitSpriteEffect { get; }

        private RenderTarget2D gPosition { get; }
        private RenderTarget2D gNormal { get; }
@ -160,7 +160,7 @@ namespace Kav
            ToneMapEffect = new Effect(graphicsDevice, Resources.ToneMapEffect);
            Deferred_ToonEffect = new Deferred_ToonEffect(GraphicsDevice);
            SkyboxEffect = new SkyboxEffect(GraphicsDevice);
-            BasicEffect = new BasicEffect(GraphicsDevice);
+            DiffuseLitSpriteEffect = new DiffuseLitSpriteEffect(GraphicsDevice);

            FullscreenTriangle = new VertexBuffer(GraphicsDevice, typeof(VertexPositionTexture), 3, BufferUsage.WriteOnly);
            FullscreenTriangle.SetData(new VertexPositionTexture[3] {
@ -245,7 +245,10 @@ namespace Kav
            RenderTarget2D renderTarget,
            PerspectiveCamera camera,
            IEnumerable<(Model, Matrix)> modelTransforms,
-            IEnumerable<Sprite> sprites
+            IEnumerable<Sprite> sprites,
+            AmbientLight ambientLight,
+            IEnumerable<PointLight> pointLights,
+            DirectionalLight directionalLight
        ) {
            GraphicsDevice.SetRenderTarget(ColorRenderTarget);
            GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1f, 0);
@ -254,20 +257,31 @@ namespace Kav
            DepthRender(camera, modelTransforms);
            GraphicsDevice.Clear(ClearOptions.Target, new Color(0, 0, 0, 0), 1f, 0);

-            BasicEffect.View = camera.View;
-            BasicEffect.Projection = camera.Projection;
-            BasicEffect.TextureEnabled = true;
-            BasicEffect.VertexColorEnabled = true;
+            DiffuseLitSpriteEffect.View = camera.View;
+            DiffuseLitSpriteEffect.Projection = camera.Projection;
+
+            DiffuseLitSpriteEffect.DirectionalLightDirection =
+                directionalLight.Direction;
+            DiffuseLitSpriteEffect.DirectionalLightColor =
+                directionalLight.Color.ToVector3() * directionalLight.Intensity;
+
+            var i = 0;
+            foreach (var pointLight in pointLights)
+            {
+                if (i > DiffuseLitSpriteEffect.MaxPointLights) { break; }
+                DiffuseLitSpriteEffect.PointLights[i] = pointLight;
+                i += 1;
+            }

            foreach (var sprite in sprites)
            {
                if (sprite.BillboardConstraint == SpriteBillboardConstraint.None)
                {
-                    BasicEffect.World = sprite.TransformMatrix;
+                    DiffuseLitSpriteEffect.World = sprite.TransformMatrix;
                }
                else if (sprite.BillboardConstraint == SpriteBillboardConstraint.Horizontal)
                {
-                    BasicEffect.World = Matrix.CreateConstrainedBillboard(
+                    DiffuseLitSpriteEffect.World = Matrix.CreateConstrainedBillboard(
                        sprite.Position,
                        camera.Position,
                        Vector3.Up,
@ -277,7 +291,7 @@ namespace Kav
                }
                else
                {
-                    BasicEffect.World = Matrix.CreateConstrainedBillboard(
+                    DiffuseLitSpriteEffect.World = Matrix.CreateConstrainedBillboard(
                        sprite.Position,
                        camera.Position,
                        Vector3.Up,
@ -286,7 +300,9 @@ namespace Kav
                    );
                }

-                SpriteBatch.Begin(0, null, null, DepthStencilState.DepthRead, RasterizerState.CullNone, BasicEffect);
+                GraphicsDevice.Textures[1] = sprite.Texture;
+
+                SpriteBatch.Begin(0, null, null, DepthStencilState.DepthRead, RasterizerState.CullNone, DiffuseLitSpriteEffect);
                SpriteBatch.Draw(
                    sprite.Texture,
                    Vector2.Zero,
--- a/Resources.cs
+++ b/Resources.cs
@ -135,6 +135,18 @@ namespace Kav
            }
        }

+        public static byte[] DiffuseLitSpriteEffect
+        {
+            get
+            {
+                if (diffuseLitSpriteEffect == null)
+                {
+                    diffuseLitSpriteEffect = GetResource("DiffuseLitSpriteEffect.fxb");
+                }
+                return diffuseLitSpriteEffect;
+            }
+        }
+
        public static byte[] UnitCubeModel
        {
            get
@ -158,6 +170,7 @@ namespace Kav
        private static byte[] simpleDepthEffect;
        private static byte[] linearDepthEffect;
        private static byte[] skyboxEffect;
+        private static byte[] diffuseLitSpriteEffect;

        private static byte[] unitCubeModel;