fix crash on 0 instance

Cameras/Camera.cs

@@ -10,6 +10,7 @@ namespace Kav
         public Vector3 Position { get; }
         public Vector3 Forward { get; }
         public Vector3 Up { get; }
+        public Vector3 Right { get; }
 
         public float FieldOfView { get; }
         public float AspectRatio { get; }
@@ -28,6 +29,7 @@ namespace Kav
             Position = position;
             Forward = forward;
             Up = up;
+            Right = Vector3.Cross(forward, up);
             View = Matrix.CreateLookAt(Position, Position + Forward, Up);
 
             FieldOfView = fieldOfView;

Data/AtlasAnimation.cs

@@ -0,0 +1,14 @@
+namespace Kav
+{
+    public struct AtlasAnimation
+    {
+        public UVData[] Frames { get; }
+        public int Framerate { get; }
+
+        public AtlasAnimation(UVData[] frames, int framerate)
+        {
+            Frames = frames;
+            Framerate = framerate;
+        }
+    }
+}

Data/InstanceData.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Kav
+{
+    public class InstanceData<T> where T : struct, IVertexType
+    {
+        public T[] InstanceDataArray { get; }
+        public DynamicVertexBuffer VertexBuffer { get; }
+        public int InstanceCount { get; private set; }
+
+        public InstanceData(GraphicsDevice graphicsDevice, int size)
+        {
+            InstanceDataArray = new T[size];
+
+            VertexBuffer = new DynamicVertexBuffer(
+                graphicsDevice,
+                typeof(T),
+                size,
+                BufferUsage.WriteOnly
+            );
+
+            InstanceCount = 0;
+        }
+
+        public void AddAndSetData(IEnumerable<T> data)
+        {
+            InstanceCount = 0;
+            foreach (var datum in data)
+            {
+                AddData(datum);
+            }
+
+            if (InstanceCount == 0) { throw new System.Exception(); }
+
+            SetData();
+        }
+
+        public void AddData(T datum)
+        {
+            InstanceDataArray[InstanceCount] = datum;
+            InstanceCount += 1;
+        }
+
+        public void SetData()
+        {
+            if (InstanceCount > 0)
+            {
+                VertexBuffer.SetData(
+                    InstanceDataArray,
+                    0,
+                    InstanceCount,
+                    SetDataOptions.NoOverwrite
+                );
+            }
+        }
+
+        public void Clear()
+        {
+            InstanceCount = 0;
+        }
+    }
+}

Data/MeshSpriteDrawData.cs

@@ -0,0 +1,35 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Kav.Data
+{
+    public struct MeshSpriteDrawData : IIndexDrawable, ICullable, ITransformable
+    {
+        public SpriteMesh MeshSprite { get; }
+        public Texture2D Texture { get; }
+        public Texture2D Normal { get; }
+        public SpriteBillboardConstraint BillboardConstraint { get; }
+        public Matrix TransformMatrix { get; }
+        public UVData UVOffset { get; }
+
+        public IndexBuffer IndexBuffer => MeshSprite.IndexBuffer;
+        public VertexBuffer VertexBuffer => MeshSprite.VertexBuffer;
+        public BoundingBox BoundingBox => MeshSprite.BoundingBox;
+
+        public MeshSpriteDrawData(
+            SpriteMesh meshSprite,
+            Texture2D texture,
+            Texture2D normal,
+            SpriteBillboardConstraint billboardConstraint,
+            Matrix transformMatrix,
+            UVData offset
+        ) {
+            MeshSprite = meshSprite;
+            Texture = texture;
+            Normal = normal;
+            BillboardConstraint = billboardConstraint;
+            TransformMatrix = transformMatrix;
+            UVOffset = offset;
+        }
+    }
+}

Data/TextureAtlas.cs

@@ -0,0 +1,96 @@
+using Kav.Data;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Kav
+{
+    public struct TextureAtlasSlice
+    {
+        public int X { get; }
+        public int Y { get; }
+        public int W { get; }
+        public int H { get; }
+
+        public UVData UVData { get; }
+
+        // for use with tiling
+        public Vector2 TiledUVOffset { get; }
+
+        public TextureAtlasSlice(int x, int y, int w, int h, int totalW, int totalH)
+        {
+            X = x;
+            Y = y;
+            W = w;
+            H = h;
+
+            UVData = new UVData(new Vector2(x, y), new Vector2(w, h), new Vector2(totalW, totalH));
+
+            TiledUVOffset = new Vector2(x / (float)totalW, y / (float)totalH);
+        }
+    }
+
+    public class TextureAtlas
+    {
+        public Texture2D Texture { get; }
+        protected List<string> Names { get; } = new List<string>();
+        protected Dictionary<string, TextureAtlasSlice> Slices { get; } = new Dictionary<string, TextureAtlasSlice>();
+
+        public TextureAtlas(GraphicsDevice graphicsDevice, FileInfo atlasMetadataFile)
+        {
+            var atlasData = CrunchAtlasReader.ReadTextureAtlas(atlasMetadataFile);
+
+            var textureData = atlasData.Textures[0];
+
+            using var stream = File.OpenRead(Path.Combine(atlasMetadataFile.DirectoryName, textureData.Name + ".png"));
+            Texture = Texture2D.FromStream(graphicsDevice, stream);
+
+            foreach (var slice in textureData.Images)
+            {
+                Names.Add(slice.N);
+
+                Slices.Add(
+                    slice.N,
+                    new TextureAtlasSlice(
+                        slice.X,
+                        slice.Y,
+                        slice.W,
+                        slice.H,
+                        Texture.Width,
+                        Texture.Height
+                    )
+                );
+            }
+        }
+
+        public TextureAtlasSlice Lookup(string name)
+        {
+            return Slices[name];
+        }
+
+        public string Name(int index)
+        {
+            return Names[index];
+        }
+
+        public int Count()
+        {
+            return Names.Count;
+        }
+    }
+
+    // Assumes all subimages are the same size
+    public class TiledTextureAtlas : TextureAtlas
+    {
+        public int NumRows { get; }
+        public int NumColumns { get; }
+
+        public TiledTextureAtlas(GraphicsDevice graphicsDevice, FileInfo atlasMetadataFile) : base(graphicsDevice, atlasMetadataFile)
+        {
+            var subImageSlice = Slices[Names[0]];
+            NumRows = Texture.Height / subImageSlice.H;
+            NumColumns = Texture.Width / subImageSlice.W;
+        }
+    }
+}

Data/UVData.cs

@@ -0,0 +1,19 @@
+using Microsoft.Xna.Framework;
+
+namespace Kav
+{
+    public struct UVData
+    {
+        public Vector2 Offset { get; }
+        public Vector2 Percentage { get; }
+
+        public UVData(
+            Vector2 positionInAtlas,
+            Vector2 subTextureDimensions,
+            Vector2 atlasDimensions
+        ) {
+            Percentage = subTextureDimensions / atlasDimensions;
+            Offset = positionInAtlas / atlasDimensions;
+        }
+    }
+}

Effects/DeferredPBREffect.cs

@@ -74,32 +74,6 @@ namespace Kav
             );
         }
 
-        protected DeferredPBREffect(DeferredPBREffect cloneSource) : base(cloneSource)
-        {
-            GPosition = cloneSource.GPosition;
-            GAlbedo = cloneSource.GAlbedo;
-            GNormal = cloneSource.GNormal;
-            GMetallicRoughness = cloneSource.GMetallicRoughness;
-
-            EyePosition = cloneSource.EyePosition;
-
-            PointLights = new PointLightCollection(
-                Parameters["LightPositions"],
-                Parameters["PositionLightColors"],
-                MaxPointLights
-            );
-
-            for (int i = 0; i < MaxPointLights; i++)
-            {
-                PointLights[i] = cloneSource.PointLights[i];
-            }
-        }
-
-        public override Effect Clone()
-        {
-            return new DeferredPBREffect(this);
-        }
-
         protected override void OnApply()
         {
             gPositionParam.SetValue(GPosition);

Effects/DeferredPBR_GBufferEffect.cs

@@ -16,6 +16,9 @@ namespace Kav
         EffectParameter metallicParam;
         EffectParameter roughnessParam;
 
+        EffectParameter uvOffsetAndDimensionsParam;
+        EffectParameter isSpriteParam;
+
         EffectParameter numTextureRowsParam;
         EffectParameter numTextureColumnsParam;
 
@@ -30,6 +33,11 @@ namespace Kav
         float metallic;
         float roughness;
 
+        Vector2 uvOffset;
+        Vector2 subTextureDimensions;
+
+        bool isSprite = false;
+
         int numTextureRows = 1;
         int numTextureColumns = 1;
 
@@ -153,6 +161,36 @@ namespace Kav
             }
         }
 
+        public Vector2 UVOffset
+        {
+            get { return uvOffset; }
+            set
+            {
+                uvOffset = value;
+                dirtyFlags |= EffectDirtyFlags.UVOrDimensions;
+            }
+        }
+
+        public Vector2 SubTextureDimensions
+        {
+            get { return subTextureDimensions; }
+            set
+            {
+                subTextureDimensions = value;
+                dirtyFlags |= EffectDirtyFlags.UVOrDimensions;
+            }
+        }
+
+        public bool IsSprite
+        {
+            get { return isSprite; }
+            set
+            {
+                isSprite = value;
+                isSpriteParam.SetValue(isSprite ? 1f : 0f);
+            }
+        }
+
         public bool HardwareInstancingEnabled
         {
             get { return hardwareInstancingEnabled; }
@@ -210,6 +248,16 @@ namespace Kav
                 dirtyFlags &= ~EffectDirtyFlags.ViewProj;
             }
 
+            if ((dirtyFlags & EffectDirtyFlags.UVOrDimensions) != 0)
+            {
+                uvOffsetAndDimensionsParam.SetValue(new Vector4(
+                    UVOffset.X, UVOffset.Y,
+                    SubTextureDimensions.X, SubTextureDimensions.Y
+                ));
+
+                dirtyFlags &= ~EffectDirtyFlags.UVOrDimensions;
+            }
+
             if ((dirtyFlags & EffectDirtyFlags.VertexShaderIndex) != 0)
             {
                 int vertexShaderIndex = 0;
@@ -277,6 +325,9 @@ namespace Kav
             numTextureRowsParam = Parameters["NumTextureRows"];
             numTextureColumnsParam = Parameters["NumTextureColumns"];
 
+            uvOffsetAndDimensionsParam = Parameters["UVOffsetAndDimensions"];
+            isSpriteParam = Parameters["IsSprite"];
+
             shaderIndexParam = Parameters["PixelShaderIndex"];
             vertexShaderIndexParam = Parameters["VertexShaderIndex"];
         }

Effects/DeferredPBR_PointLightEffect.cs

@@ -18,6 +18,8 @@ namespace Kav
 
         EffectParameter farPlaneParam;
 
+        EffectParameter worldViewProjectionParam;
+
         public Texture2D GPosition { get; set; }
         public Texture2D GAlbedo { get; set; }
         public Texture2D GNormal { get; set; }
@@ -31,6 +33,42 @@ namespace Kav
 
         public float FarPlane { get; set; }
 
+        Matrix world = Matrix.Identity;
+        Matrix view = Matrix.Identity;
+        Matrix projection = Matrix.Identity;
+
+        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
+
+        public Matrix World
+        {
+            get { return world; }
+            set
+            {
+                world = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+        public Matrix View
+        {
+            get { return view; }
+            set
+            {
+                view = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+        public Matrix Projection
+        {
+            get { return projection; }
+            set
+            {
+                projection = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
         public DeferredPBR_PointLightEffect(GraphicsDevice graphicsDevice) : base(graphicsDevice, Resources.DeferredPBR_PointLightEffect)
         {
             CacheEffectParameters();
@@ -73,6 +111,13 @@ namespace Kav
             pointLightColorParam.SetValue(PointLightColor);
 
             farPlaneParam.SetValue(FarPlane);
+
+            if ((dirtyFlags & EffectDirtyFlags.WorldViewProj) != 0)
+            {
+                worldViewProjectionParam.SetValue(world * view * projection);
+
+                dirtyFlags &= ~EffectDirtyFlags.WorldViewProj;
+            }
         }
 
         void CacheEffectParameters()
@@ -89,6 +134,8 @@ namespace Kav
             pointLightColorParam           = Parameters["PointLightColor"];
 
             farPlaneParam                  = Parameters["FarPlane"];
+
+            worldViewProjectionParam       = Parameters["WorldViewProjection"];
         }
     }
 }

Effects/DiffuseLitSpriteEffect.cs

@@ -1,3 +1,4 @@
+using Kav.Data;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 
@@ -10,6 +11,8 @@ namespace Kav
         EffectParameter directionalLightDirectionParam;
         EffectParameter directionalLightColorParam;
 
+        EffectParameter uvOffsetAndDimensionsParam;
+
         EffectParameter worldParam;
         EffectParameter worldViewProjectionParam;
         EffectParameter worldInverseTransposeParam;
@@ -30,6 +33,9 @@ namespace Kav
         Matrix view = Matrix.Identity;
         Matrix projection = Matrix.Identity;
 
+        Vector2 uvOffset;
+        Vector2 subTextureDimensions;
+
         EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
 
         public bool NormalMapEnabled
@@ -109,6 +115,26 @@ namespace Kav
             }
         }
 
+        public Vector2 UVOffset
+        {
+            get { return uvOffset; }
+            set
+            {
+                uvOffset = value;
+                dirtyFlags |= EffectDirtyFlags.UVOrDimensions;
+            }
+        }
+
+        public Vector2 SubTextureDimensions
+        {
+            get { return subTextureDimensions; }
+            set
+            {
+                subTextureDimensions = value;
+                dirtyFlags |= EffectDirtyFlags.UVOrDimensions;
+            }
+        }
+
         public DiffuseLitSpriteEffect(GraphicsDevice graphicsDevice) : base(graphicsDevice, Resources.DiffuseLitSpriteEffect)
         {
             CacheEffectParameters();
@@ -142,6 +168,16 @@ namespace Kav
                 dirtyFlags &= ~EffectDirtyFlags.WorldViewProj;
             }
 
+            if ((dirtyFlags & EffectDirtyFlags.UVOrDimensions) != 0)
+            {
+                uvOffsetAndDimensionsParam.SetValue(new Vector4(
+                    UVOffset.X, UVOffset.Y,
+                    SubTextureDimensions.X, SubTextureDimensions.Y
+                ));
+
+                dirtyFlags &= ~EffectDirtyFlags.UVOrDimensions;
+            }
+
             if ((dirtyFlags & EffectDirtyFlags.PixelShaderIndex) != 0)
             {
                 int shaderIndex = 0;
@@ -166,6 +202,8 @@ namespace Kav
             directionalLightDirectionParam = Parameters["DirectionalLightDirection"];
             directionalLightColorParam = Parameters["DirectionalLightColor"];
 
+            uvOffsetAndDimensionsParam = Parameters["UVOffsetAndDimensions"];
+
             shaderIndexParam = Parameters["ShaderIndex"];
         }
     }

Effects/EffectHelpers.cs

@@ -11,6 +11,7 @@ namespace Kav
         VertexShaderIndex = 8,
         PixelShaderIndex = 16,
         ViewProj = 32,
+        UVOrDimensions = 64,
         All = -1
     }
 }

Effects/HLSL/DeferredPBR_GBufferEffect.fx

@@ -4,6 +4,9 @@ DECLARE_TEXTURE(AlbedoTexture, 0);
 DECLARE_TEXTURE(NormalTexture, 1);
 DECLARE_TEXTURE(MetallicRoughnessTexture, 2);
 
+float4 UVOffsetAndDimensions;
+float IsSprite;
+
 BEGIN_CONSTANTS
 
     float3 AlbedoValue                         _ps(c0)    _cb(c0);
@@ -51,7 +54,11 @@ PixelInput main_vs(VertexInput input)
 
     output.PositionWorld = mul(input.Position, World).xyz;
     output.NormalWorld = normalize(mul(input.Normal, World));
-    output.TexCoord = input.TexCoord;
+
+    float2 texCoord;
+    texCoord.x = (input.TexCoord.x * UVOffsetAndDimensions.z) + UVOffsetAndDimensions.x;
+    texCoord.y = (input.TexCoord.y * UVOffsetAndDimensions.w) + UVOffsetAndDimensions.y;
+    output.TexCoord = texCoord;
 
     float4x4 worldViewProjection = mul(World, ViewProjection);
     output.Position = mul(input.Position, worldViewProjection);
@@ -113,7 +120,7 @@ PixelOutput NonePS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(normalize(input.NormalWorld), 1.0);
+    output.gNormal = float4(normalize(input.NormalWorld), IsSprite);
     output.gAlbedo = float4(AlbedoValue, 1.0);
     output.gMetallicRoughness = float4(MetallicValue, RoughnessValue, 0.0, 1.0);
 
@@ -125,10 +132,12 @@ PixelOutput AlbedoPS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(normalize(input.NormalWorld), 1.0);
+    output.gNormal = float4(normalize(input.NormalWorld), IsSprite);
     output.gAlbedo = SAMPLE_TEXTURE(AlbedoTexture, input.TexCoord);
     output.gMetallicRoughness = float4(MetallicValue, RoughnessValue, 0.0, 1.0);
 
+    if (output.gAlbedo.a == 0.0) { discard; }
+
     return output;
 }
 
@@ -137,7 +146,7 @@ PixelOutput MetallicRoughnessPS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(normalize(input.NormalWorld), 1.0);
+    output.gNormal = float4(normalize(input.NormalWorld), IsSprite);
     output.gAlbedo = float4(AlbedoValue, 1.0);
     output.gMetallicRoughness = SAMPLE_TEXTURE(MetallicRoughnessTexture, input.TexCoord);
 
@@ -149,7 +158,7 @@ PixelOutput NormalPS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), 1.0);
+    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), IsSprite);
     output.gAlbedo = float4(AlbedoValue, 1.0);
     output.gMetallicRoughness = float4(MetallicValue, RoughnessValue, 0.0, 1.0);
 
@@ -161,10 +170,12 @@ PixelOutput AlbedoMetallicRoughnessPS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(normalize(input.NormalWorld), 1.0);
+    output.gNormal = float4(normalize(input.NormalWorld), IsSprite);
     output.gAlbedo = SAMPLE_TEXTURE(AlbedoTexture, input.TexCoord);
     output.gMetallicRoughness = SAMPLE_TEXTURE(MetallicRoughnessTexture, input.TexCoord);
 
+    if (output.gAlbedo.a == 0.0) { discard; }
+
     return output;
 }
 
@@ -173,10 +184,12 @@ PixelOutput AlbedoNormalPS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), 1.0);
+    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), IsSprite);
     output.gAlbedo = SAMPLE_TEXTURE(AlbedoTexture, input.TexCoord);
     output.gMetallicRoughness = float4(MetallicValue, RoughnessValue, 0.0, 1.0);
 
+    if (output.gAlbedo.a == 0.0) { discard; }
+
     return output;
 }
 
@@ -185,7 +198,7 @@ PixelOutput MetallicRoughnessNormalPS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), 1.0);
+    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), IsSprite);
     output.gAlbedo = float4(AlbedoValue, 1.0);
     output.gMetallicRoughness = SAMPLE_TEXTURE(MetallicRoughnessTexture, input.TexCoord);
 
@@ -197,10 +210,12 @@ PixelOutput AlbedoMetallicRoughnessNormalMapPS(PixelInput input)
     PixelOutput output;
 
     output.gPosition = float4(input.PositionWorld, 1.0);
-    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), 1.0);
+    output.gNormal = float4(GetNormalFromMap(input.PositionWorld, input.TexCoord, input.NormalWorld), IsSprite);
     output.gAlbedo = SAMPLE_TEXTURE(AlbedoTexture, input.TexCoord);
     output.gMetallicRoughness = SAMPLE_TEXTURE(MetallicRoughnessTexture, input.TexCoord);
 
+    if (output.gAlbedo.a == 0.0) { discard; }
+
     return output;
 }
 

Effects/HLSL/DeferredPBR_PointLightEffect.fx

@@ -1,3 +1,5 @@
+// Assumes you are drawing a sphere!!
+
 #include "Macros.fxh" //from FNA
 #include "Lighting.fxh"
 #include "Shadow.fxh"
@@ -19,26 +21,27 @@ BEGIN_CONSTANTS
 
 MATRIX_CONSTANTS
 
+    float4x4 WorldViewProjection _vs(c0)                _cb(c4);
+
 END_CONSTANTS
 
 struct VertexInput
 {
     float4 Position : POSITION;
-    float2 TexCoord : TEXCOORD;
 };
 
 struct PixelInput
 {
     float4 Position : SV_POSITION;
-    float2 TexCoord : TEXCOORD0;
+    float4 ScreenPosition : TEXCOORD0;
 };
 
 PixelInput main_vs(VertexInput input)
 {
     PixelInput output;
 
-    output.Position = input.Position;
+    output.Position = mul(input.Position, WorldViewProjection);
-    output.TexCoord = input.TexCoord;
+    output.ScreenPosition = output.Position;
 
     return output;
 }
@@ -73,11 +76,28 @@ float4 ComputeColor(
 
 float4 main_ps(PixelInput input) : SV_TARGET0
 {
-    float3 worldPosition = SAMPLE_TEXTURE(gPosition, input.TexCoord).rgb;
+    input.ScreenPosition.xy /= input.ScreenPosition.w;
-    float3 normal = SAMPLE_TEXTURE(gNormal, input.TexCoord).xyz;
+    float2 texCoord = 0.5f * float2(input.ScreenPosition.x,-input.ScreenPosition.y) + 0.5f;
-    float3 albedo = SAMPLE_TEXTURE(gAlbedo, input.TexCoord).rgb;
-    float2 metallicRoughness = SAMPLE_TEXTURE(gMetallicRoughness, input.TexCoord).rg;
 
+    float3 worldPosition = SAMPLE_TEXTURE(gPosition, texCoord).rgb;
+    float4 normalSample = SAMPLE_TEXTURE(gNormal, texCoord);
+    float3 normal = normalSample.xyz;
+    float isSprite = normalSample.a;
+    float3 albedo = SAMPLE_TEXTURE(gAlbedo, texCoord).rgb;
+    float2 metallicRoughness = SAMPLE_TEXTURE(gMetallicRoughness, texCoord).rg;
+
+    if (isSprite == 1.0)
+    {
+        float3 lightDir = PointLightPosition - worldPosition;
+        float3 L = normalize(lightDir);
+        float distance = length(lightDir);
+        float attenuation = 1.0 / (distance * distance);
+        float3 radiance = PointLightColor * attenuation;
+
+        return float4(albedo * radiance * 0.1, 1.0);
+    }
+    else
+    {
         return ComputeColor(
             worldPosition,
             normal,
@@ -86,6 +106,7 @@ float4 main_ps(PixelInput input) : SV_TARGET0
             metallicRoughness.g
         );
     }
+}
 
 Technique DeferredPBR_Point
 {

Effects/HLSL/DiffuseLitSpriteEffect.fx

@@ -5,23 +5,19 @@
 DECLARE_TEXTURE(Texture, 0);
 DECLARE_TEXTURE(Normal, 1);
 
-BEGIN_CONSTANTS
+float3 AmbientColor;
 
-    float3 AmbientColor                       _ps(c0)    _cb(c0);
+float3 PointLightPositions[8];
+float3 PointLightColors[8];
 
-    float3 PointLightPositions[8]            _ps(c1)    _cb(c1);
+float3 DirectionalLightDirection;
-    float3 PointLightColors[8]               _ps(c9)    _cb(c9);
+float3 DirectionalLightColor;
 
-    float3 DirectionalLightDirection          _ps(c17)   _cb(c17);
+float4 UVOffsetAndDimensions;
-    float3 DirectionalLightColor              _ps(c18)   _cb(c18);
 
-MATRIX_CONSTANTS
+float4x4 WorldInverseTranspose;
-
+float4x4 World;
-    float4x4 WorldInverseTranspose           _ps(c19)   _cb(c19);
+float4x4 WorldViewProjection;
-    float4x4 World                  _vs(c0)             _cb(c23);
-    float4x4 WorldViewProjection    _vs(c4)             _cb(c27);
-
-END_CONSTANTS
 
 struct VertexShaderInput
 {
@@ -43,10 +39,14 @@ PixelShaderInput main_vs(VertexShaderInput input)
     PixelShaderInput output;
 
     output.Position = mul(input.Position, WorldViewProjection);
-    output.TexCoord = input.TexCoord;
+    output.NormalWS = normalize(mul(input.Normal, (float3x3)WorldInverseTranspose));
-    output.NormalWS = mul(input.Normal, (float3x3)WorldInverseTranspose).xyz;
     output.PositionWS = mul(input.Position, World).xyz;
 
+    float2 texCoord;
+    texCoord.x = (input.TexCoord.x * UVOffsetAndDimensions.z) + UVOffsetAndDimensions.x;
+    texCoord.y = (input.TexCoord.y * UVOffsetAndDimensions.w) + UVOffsetAndDimensions.y;
+    output.TexCoord = texCoord;
+
     return output;
 }
 
@@ -98,6 +98,9 @@ float4 LightColor(float3 worldPosition, float3 worldNormal)
 float4 WithoutNormalMap(PixelShaderInput input) : COLOR0
 {
     float4 tex = SAMPLE_TEXTURE(Texture, input.TexCoord);
+
+    if (tex.a == 0.0) { discard; }
+
     float3 normalWS = normalize(input.NormalWS);
 
     return tex * LightColor(input.PositionWS, normalWS);
@@ -106,6 +109,9 @@ float4 WithoutNormalMap(PixelShaderInput input) : COLOR0
 float4 WithNormalMap(PixelShaderInput input) : COLOR0
 {
     float4 tex = SAMPLE_TEXTURE(Texture, input.TexCoord);
+
+    if (tex.a == 0.0) { discard; }
+
     float3 normalWS = GetNormalFromMap(input.PositionWS, input.TexCoord, input.NormalWS);
 
     return tex * LightColor(input.PositionWS, normalWS);

Effects/HLSL/PaletteCrushEffect.fx

@@ -1,7 +1,5 @@
 #include "Macros.fxh"
 
-#define FLT_MAX 3.402823466e+38
-
 DECLARE_TEXTURE(Texture, 0);
 DECLARE_TEXTURE(Palette, 1);
 
@@ -40,11 +38,12 @@ float4 main_ps(PixelInput input) : SV_TARGET0
 	float3 sampled_color = sampled.rgb;
 	
 	float3 closest_color = float3(0, 0, 0);
-	float closest_dist = FLT_MAX;
+	float closest_dist = 100000;
 
 	for (int i = 0; i < PaletteWidth; i++)
 	{
-		float3 palette_color = SAMPLE_TEXTURE(Palette, float2(i / (float)PaletteWidth, 0));
+		float texX = (i / (float)PaletteWidth);
+		float3 palette_color = SAMPLE_TEXTURE(Palette, float2(texX, 0));
 		float dist = distance(palette_color, sampled_color);
 		if (dist < closest_dist)
 		{

Effects/PBREffect.cs

@@ -197,45 +197,6 @@ namespace Kav
             );
         }
 
-        protected PBREffect(PBREffect cloneSource) : base(cloneSource)
-        {
-            CacheEffectParameters();
-
-            World = cloneSource.World;
-            View = cloneSource.View;
-            Projection = cloneSource.Projection;
-
-            PointLights = new PointLightCollection(
-                Parameters["LightPositions"],
-                Parameters["PositionLightColors"],
-                MaxPointLights
-            );
-
-            for (int i = 0; i < MaxPointLights; i++)
-            {
-                PointLights[i] = cloneSource.PointLights[i];
-            }
-
-            AlbedoTexture = cloneSource.AlbedoTexture;
-            NormalTexture = cloneSource.NormalTexture;
-            EmissionTexture = cloneSource.EmissionTexture;
-            OcclusionTexture = cloneSource.OcclusionTexture;
-            MetallicRoughnessTexture = cloneSource.MetallicRoughnessTexture;
-            EnvDiffuseTexture = cloneSource.EnvDiffuseTexture;
-            BRDFLutTexture = cloneSource.BRDFLutTexture;
-            EnvSpecularTexture = cloneSource.EnvSpecularTexture;
-
-            Albedo = cloneSource.Albedo;
-            Metallic = cloneSource.Metallic;
-            Roughness = cloneSource.Roughness;
-            AO = cloneSource.AO;
-        }
-
-        public override Effect Clone()
-        {
-            return new PBREffect(this);
-        }
-
         protected override void OnApply()
         {
             if ((dirtyFlags & EffectDirtyFlags.World) != 0)

Effects/PointLightCollection.cs

@@ -7,41 +7,24 @@ namespace Kav
     {
         private readonly Vector3[] positions;
         private readonly Vector3[] colors;
-        private readonly float[] intensities;
 
         readonly EffectParameter lightPositionsParam;
         readonly EffectParameter lightColorsParam;
 
         public PointLightCollection(EffectParameter lightPositionsParam, EffectParameter lightColorsParam, int maxLights)
         {
-            this.positions = new Vector3[maxLights];
+            positions = new Vector3[maxLights];
-            this.colors = new Vector3[maxLights];
+            colors = new Vector3[maxLights];
-            this.intensities = new float[maxLights];
             this.lightPositionsParam = lightPositionsParam;
             this.lightColorsParam = lightColorsParam;
         }
 
         public PointLight this[int i]
         {
-            get
-            {
-                var color = colors[i] / intensities[i];
-                return new PointLight(
-                    positions[i],
-                    new Color(
-                        color.X,
-                        color.Y,
-                        color.Z,
-                        1f
-                    ),
-                    intensities[i]
-                );
-            }
             set
             {
                 positions[i] = value.Position;
-                colors[i] = value.Color.ToVector3() * value.Intensity;
+                colors[i] = value.Color.ToVector3() * value.Radius;
-                intensities[i] = value.Intensity;
                 lightPositionsParam.SetValue(positions);
                 lightColorsParam.SetValue(colors);
             }

Geometry/Interfaces/ITransformable.cs

@@ -0,0 +1,9 @@
+using Microsoft.Xna.Framework;
+
+namespace Kav
+{
+    public interface ITransformable
+    {
+        Matrix TransformMatrix { get; }
+    }
+}

Geometry/MeshSprite.cs

@@ -1,115 +0,0 @@
-using System.Collections.Generic;
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Graphics;
-
-namespace Kav
-{
-    public class MeshSprite : ICullable, IIndexDrawable
-    {
-        private static readonly int PixelScale = 40;
-        private static readonly short[] Indices = new short[]
-        {
-            0,
-            1,
-            2,
-            1,
-            3,
-            2
-        };
-
-        public Texture2D Texture { get; }
-        public Texture2D Normal { get; }
-
-        public IndexBuffer IndexBuffer { get; }
-        public VertexBuffer VertexBuffer { get; }
-        public BoundingBox BoundingBox { get; }
-
-        public MeshSprite(
-            GraphicsDevice graphicsDevice,
-            Texture2D texture
-        ) {
-            Texture = texture;
-            Normal = null;
-
-			IndexBuffer = new IndexBuffer(
-				graphicsDevice,
-				IndexElementSize.SixteenBits,
-				6,
-				BufferUsage.WriteOnly
-			);
-            IndexBuffer.SetData(Indices);
-
-            var vertexArray = GenerateVertexArray(Texture);
-
-            VertexBuffer = new VertexBuffer(
-                graphicsDevice,
-                typeof(VertexPositionNormalTexture),
-                4,
-                BufferUsage.WriteOnly
-            );
-            VertexBuffer.SetData(vertexArray);
-
-            BoundingBox = BoundingBox.CreateFromPoints(Positions(vertexArray));
-        }
-
-        public MeshSprite(
-            GraphicsDevice graphicsDevice,
-            Texture2D texture,
-            Texture2D normal
-        ) {
-            Texture = texture;
-            Normal = normal;
-
-			IndexBuffer = new IndexBuffer(
-				graphicsDevice,
-				IndexElementSize.SixteenBits,
-				6,
-				BufferUsage.WriteOnly
-			);
-            IndexBuffer.SetData(Indices);
-
-            var vertexArray = GenerateVertexArray(Texture);
-
-            VertexBuffer = new VertexBuffer(
-                graphicsDevice,
-                typeof(VertexPositionNormalTexture),
-                4,
-                BufferUsage.WriteOnly
-            );
-            VertexBuffer.SetData(vertexArray);
-
-            BoundingBox = BoundingBox.CreateFromPoints(Positions(vertexArray));
-        }
-
-        private static VertexPositionNormalTexture[] GenerateVertexArray(Texture2D texture)
-        {
-            VertexPositionNormalTexture[] result = new VertexPositionNormalTexture[4];
-
-            result[0].Position = new Vector3(-texture.Width / 2, texture.Height / 2, 0) / PixelScale;
-            result[0].Normal = new Vector3(0, 0, 1);
-            result[0].TextureCoordinate = new Vector2(0, 0);
-
-            result[1].Position = new Vector3(texture.Width / 2, texture.Height / 2, 0) / PixelScale;
-            result[1].Normal = new Vector3(0, 0, 1);
-            result[1].TextureCoordinate = new Vector2(1, 0);
-
-            result[2].Position = new Vector3(-texture.Width / 2, -texture.Height / 2, 0) / PixelScale;
-            result[2].Normal = new Vector3(0, 0, 1);
-            result[2].TextureCoordinate = new Vector2(0, 1);
-
-            result[3].Position = new Vector3(texture.Width / 2, -texture.Height / 2, 0) / PixelScale;
-            result[3].Normal = new Vector3(0, 0, 1);
-            result[3].TextureCoordinate = new Vector2(1, 1);
-
-            return result;
-        }
-
-        private static IEnumerable<Vector3> Positions(IEnumerable<VertexPositionNormalTexture> vertices)
-        {
-            foreach (var vertex in vertices)
-            {
-                yield return vertex.Position;
-            }
-        }
-    }
-}

Geometry/SpriteMesh.cs

@@ -0,0 +1,109 @@
+using System.Collections.Generic;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Kav
+{
+    public class SpriteMesh : ICullable, IIndexDrawable
+    {
+        public enum FlipOptions
+        {
+            None,
+            Horizontal,
+            Vertical,
+            Both
+        }
+
+        private static readonly short[] Indices = new short[]
+        {
+            0,
+            1,
+            2,
+            1,
+            3,
+            2
+        };
+
+        public IndexBuffer IndexBuffer { get; }
+        public VertexBuffer VertexBuffer { get; }
+        public BoundingBox BoundingBox { get; }
+
+        public SpriteMesh(
+            GraphicsDevice graphicsDevice,
+            int width,
+            int height,
+            FlipOptions flipOptions
+        ) {
+			IndexBuffer = new IndexBuffer(
+				graphicsDevice,
+				IndexElementSize.SixteenBits,
+				6,
+				BufferUsage.WriteOnly
+			);
+            IndexBuffer.SetData(Indices);
+
+            var vertexArray = GenerateVertexArray(width, height, flipOptions);
+
+            VertexBuffer = new VertexBuffer(
+                graphicsDevice,
+                typeof(VertexPositionNormalTexture),
+                4,
+                BufferUsage.WriteOnly
+            );
+            VertexBuffer.SetData(vertexArray);
+
+            BoundingBox = BoundingBox.CreateFromPoints(Positions(vertexArray));
+        }
+
+        private static VertexPositionNormalTexture[] GenerateVertexArray(int pixelWidth, int pixelHeight, FlipOptions flipOptions)
+        {
+            var width = pixelWidth / (float)40;
+            var height = pixelHeight / (float)40;
+
+            VertexPositionNormalTexture[] result = new VertexPositionNormalTexture[4];
+
+            var xLeft = 0;
+            var xRight = 1;
+
+            var yTop = 0;
+            var yBottom = 1;
+
+            if (flipOptions == FlipOptions.Horizontal || flipOptions == FlipOptions.Both)
+            {
+                xLeft = 1;
+                xRight = 0;
+            }
+            if (flipOptions == FlipOptions.Vertical || flipOptions == FlipOptions.Both)
+            {
+                yTop = 1;
+                yBottom = 0;
+            }
+
+            result[0].Position = new Vector3(-width / 2, height / 2, 0);
+            result[0].Normal = new Vector3(0, 0, -1);
+            result[0].TextureCoordinate = new Vector2(xLeft, yTop);
+
+            result[1].Position = new Vector3(width / 2, height / 2, 0);
+            result[1].Normal = new Vector3(0, 0, -1);
+            result[1].TextureCoordinate = new Vector2(xRight, yTop);
+
+            result[2].Position = new Vector3(-width / 2, -height / 2, 0);
+            result[2].Normal = new Vector3(0, 0, -1);
+            result[2].TextureCoordinate = new Vector2(xLeft, yBottom);
+
+            result[3].Position = new Vector3(width / 2, -height / 2, 0);
+            result[3].Normal = new Vector3(0, 0, -1);
+            result[3].TextureCoordinate = new Vector2(xRight, yBottom);
+
+            return result;
+        }
+
+        private static IEnumerable<Vector3> Positions(IEnumerable<VertexPositionNormalTexture> vertices)
+        {
+            foreach (var vertex in vertices)
+            {
+                yield return vertex.Position;
+            }
+        }
+    }
+}

Kav.Core.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>8.0</LangVersion>
     <RootNamespace>Kav</RootNamespace>
     <Authors>Evan Hemsley</Authors>
     <Copyright>Evan Hemsley 2020</Copyright>
@@ -64,6 +65,9 @@
     <EmbeddedResource Include="Models\UnitCube.glb">
       <LogicalName>Kav.Resources.UnitCube.glb</LogicalName>
 		</EmbeddedResource>
+    <EmbeddedResource Include="Models\UnitSphere.glb">
+      <LogicalName>Kav.Resources.UnitSphere.glb</LogicalName>
+		</EmbeddedResource>
   </ItemGroup>
 
 </Project>

Kav.Framework.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>8.0</LangVersion>
     <RootNamespace>Kav</RootNamespace>
     <Authors>Evan Hemsley</Authors>
     <Copyright>Evan Hemsley 2020</Copyright>
@@ -64,6 +65,9 @@
     <EmbeddedResource Include="Models\UnitCube.glb">
       <LogicalName>Kav.Resources.UnitCube.glb</LogicalName>
 		</EmbeddedResource>
+    <EmbeddedResource Include="Models\UnitSphere.glb">
+      <LogicalName>Kav.Resources.UnitSphere.glb</LogicalName>
+		</EmbeddedResource>
   </ItemGroup>
 
 </Project>

Lights/PointLight.cs

@@ -1,18 +1,55 @@
 using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
 
 namespace Kav
 {
-    public struct PointLight
+    public sealed class PointLight : IDisposable
     {
         public Vector3 Position { get; }
         public Color Color { get; }
-        public float Intensity { get; }
+        public float Radius { get; }
 
-        public PointLight(Vector3 position, Color color, float intensity = 1f)
+        public BoundingSphere BoundingSphere { get; }
-        {
+
+        public RenderTargetCube ShadowMap { get; }
+
+        public PointLight(
+            GraphicsDevice graphicsDevice,
+            Vector3 position, 
+            Color color, 
+            float radius,
+            int shadowMapSize
+        ) {
             Position = position;
             Color = color;
-            Intensity = intensity;
+            Radius = radius;
+
+            BoundingSphere = new BoundingSphere(position, Radius);
+
+            ShadowMap = new RenderTargetCube(
+                graphicsDevice,
+                shadowMapSize,
+                false,
+                SurfaceFormat.Single,
+                DepthFormat.Depth24,
+                0,
+                RenderTargetUsage.PreserveContents
+            );
+
+            var currentRTs = graphicsDevice.GetRenderTargets();
+            foreach (CubeMapFace face in Enum.GetValues(typeof(CubeMapFace)))
+            {
+                graphicsDevice.SetRenderTarget(ShadowMap, face);
+                graphicsDevice.Clear(Color.White);
+            }
+
+            graphicsDevice.SetRenderTargets(currentRTs);
+        }
+
+        public void Dispose()
+        {
+            ShadowMap.Dispose();
         }
     }
 }

Loaders/CrunchAtlasReader.cs

@@ -0,0 +1,18 @@
+using System.IO;
+using System.Text.Json;
+
+namespace Kav
+{
+    public static class CrunchAtlasReader
+    {
+        static JsonSerializerOptions options = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true
+        };
+
+        public static CrunchTextureAtlasData ReadTextureAtlas(FileInfo file)
+        {
+            return JsonSerializer.Deserialize<CrunchTextureAtlasData>(File.ReadAllText(file.FullName), options);
+        }
+    }
+}

Loaders/CrunchTextureAtlasData.cs

@@ -0,0 +1,22 @@
+namespace Kav
+{
+    public struct CrunchTextureAtlasData
+    {
+        public CrunchTextureAtlasTextureData[] Textures { get; set; }
+    }
+
+    public struct CrunchTextureAtlasTextureData
+    {
+        public string Name { get; set; }
+        public CrunchTextureAtlasImageData[] Images { get; set; }
+    }
+
+    public struct CrunchTextureAtlasImageData
+    {
+        public string N { get; set; }
+        public int X { get; set; }
+        public int Y { get; set; }
+        public int W { get; set; }
+        public int H { get; set; }
+    }
+}

Renderer.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using Kav.Data;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 
@@ -28,6 +29,7 @@ namespace Kav
         private DiffuseLitSpriteEffect DiffuseLitSpriteEffect { get; }
 
         private Kav.Model UnitCube { get; }
+        private Kav.Model UnitSphere { get; }
 
         public Renderer(
             GraphicsDevice graphicsDevice
@@ -61,6 +63,11 @@ namespace Kav
                 GraphicsDevice,
                 Smuggler.Importer.ImportGLB(GraphicsDevice, new MemoryStream(Resources.UnitCubeModel))
             );
+
+            UnitSphere = Kav.ModelLoader.Load(
+                graphicsDevice,
+                Smuggler.Importer.ImportGLB(graphicsDevice, new MemoryStream(Resources.UnitSphereModel))
+            );
         }
 
         public static (T[], DynamicVertexBuffer) CreateInstanceVertexBuffer<T>(
@@ -111,14 +118,14 @@ namespace Kav
         public void MeshSpriteRender(
             RenderTarget2D renderTarget,
             PerspectiveCamera camera,
-            IEnumerable<(MeshSprite, SpriteBillboardConstraint, Matrix)> meshSpriteBillboardTransforms,
+            IEnumerable<MeshSpriteDrawData> meshSpriteDrawDatas,
             AmbientLight ambientLight,
             IEnumerable<PointLight> pointLights,
             DirectionalLight? directionalLight
         ) {
             GraphicsDevice.SetRenderTarget(renderTarget);
 
-            GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
+            GraphicsDevice.DepthStencilState = DepthStencilState.Default;
             GraphicsDevice.RasterizerState = RasterizerState.CullNone;
             GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp;
             GraphicsDevice.SamplerStates[1] = SamplerState.PointClamp;
@@ -152,17 +159,26 @@ namespace Kav
 
             var boundingFrustum = new BoundingFrustum(camera.View * camera.Projection);
 
-            foreach (var (sprite, transform) in FrustumCull(boundingFrustum, BillboardTransforms(camera, meshSpriteBillboardTransforms)))
+            foreach (var data in meshSpriteDrawDatas)
             {
-                DiffuseLitSpriteEffect.NormalMapEnabled = sprite.Normal != null;
+                var matrix = BillboardTransforms(camera, data.TransformMatrix, data.BillboardConstraint);
 
-                DiffuseLitSpriteEffect.World = transform;
+                if (FrustumCull(boundingFrustum, data.MeshSprite, matrix))
+                {
+                    continue;
+                }
 
-                GraphicsDevice.Textures[0] = sprite.Texture;
+                DiffuseLitSpriteEffect.NormalMapEnabled = data.Normal != null;
-                GraphicsDevice.Textures[1] = sprite.Normal;
 
-                GraphicsDevice.SetVertexBuffer(sprite.VertexBuffer);
+                DiffuseLitSpriteEffect.World = matrix;
-                GraphicsDevice.Indices = sprite.IndexBuffer;
+                DiffuseLitSpriteEffect.UVOffset = data.UVOffset.Offset;
+                DiffuseLitSpriteEffect.SubTextureDimensions = data.UVOffset.Percentage;
+
+                GraphicsDevice.Textures[0] = data.Texture;
+                GraphicsDevice.Textures[1] = data.Normal;
+
+                GraphicsDevice.SetVertexBuffer(data.MeshSprite.VertexBuffer);
+                GraphicsDevice.Indices = data.MeshSprite.IndexBuffer;
 
                 foreach (var pass in DiffuseLitSpriteEffect.CurrentTechnique.Passes)
                 {
@@ -172,7 +188,7 @@ namespace Kav
                         PrimitiveType.TriangleList,
                         0,
                         0,
-                        sprite.VertexBuffer.VertexCount,
+                        data.MeshSprite.VertexBuffer.VertexCount,
                         0,
                         2
                     );
@@ -180,36 +196,79 @@ namespace Kav
             }
         }
 
-        private static IEnumerable<(MeshSprite, Matrix)> BillboardTransforms(
+        public void RenderMeshSpriteGBuffer(
+            RenderTargetBinding[] gBuffer,
             PerspectiveCamera camera,
-            IEnumerable<(MeshSprite, SpriteBillboardConstraint, Matrix)> meshSpriteBillboardTransforms
+            IEnumerable<MeshSpriteDrawData> meshSpriteDrawDatas,
+            DepthStencilState depthStencilState
         ) {
-            foreach (var (sprite, billboardConstraint, transform) in meshSpriteBillboardTransforms)
+            GraphicsDevice.SetRenderTargets(gBuffer);
+            GraphicsDevice.RasterizerState = RasterizerState.CullNone;
+            GraphicsDevice.DepthStencilState = depthStencilState;
+            GraphicsDevice.BlendState = BlendState.AlphaBlend;
+
+            Deferred_GBufferEffect.HardwareInstancingEnabled = false;
+            Deferred_GBufferEffect.IsSprite = true;
+
+            Deferred_GBufferEffect.View = camera.View;
+            Deferred_GBufferEffect.Projection = camera.Projection;
+
+            var boundingFrustum = new BoundingFrustum(camera.View * camera.Projection);
+
+            foreach (var data in meshSpriteDrawDatas)
             {
+                var matrix = BillboardTransforms(camera, data.TransformMatrix, data.BillboardConstraint);
+
+                if (FrustumCull(boundingFrustum, data.MeshSprite, matrix))
+                {
+                    continue;
+                }
+
+                Deferred_GBufferEffect.World = matrix;
+
+                Deferred_GBufferEffect.UVOffset = data.UVOffset.Offset;
+                Deferred_GBufferEffect.SubTextureDimensions = data.UVOffset.Percentage;
+
+                Deferred_GBufferEffect.Albedo = Color.White.ToVector3();
+                Deferred_GBufferEffect.Metallic = 0f;
+                Deferred_GBufferEffect.Roughness = 1f;
+
+                Deferred_GBufferEffect.AlbedoTexture = data.Texture;
+                Deferred_GBufferEffect.NormalTexture = data.Normal;
+                Deferred_GBufferEffect.MetallicRoughnessTexture = null;
+
+                RenderIndexed(GraphicsDevice, data, Deferred_GBufferEffect);
+            }
+        }
+
+        private static Matrix BillboardTransforms(
+            PerspectiveCamera camera,
+            Matrix transform,
+            SpriteBillboardConstraint billboardConstraint
+        ) {
             if (billboardConstraint == SpriteBillboardConstraint.None)
             {
-                    yield return (sprite, transform);
+                return transform;
             }
             else if (billboardConstraint == SpriteBillboardConstraint.Horizontal)
             {
-                    yield return (sprite, Matrix.CreateConstrainedBillboard(
+                return Matrix.CreateConstrainedBillboard(
                     transform.Translation,
                     camera.Position,
                     Vector3.Up,
                     camera.Forward,
                     camera.Position - transform.Translation
-                    ));
+                );
             }
             else
             {
-                    yield return (sprite, Matrix.CreateConstrainedBillboard(
+                return Matrix.CreateConstrainedBillboard(
                     transform.Translation,
                     camera.Position,
                     Vector3.Up,
                     null,
                     null
-                    ));
+                );
-                }
             }
         }
 
@@ -319,6 +378,21 @@ namespace Kav
             );
         }
 
+        public void RenderDepthIndexed<T>(
+            RenderTarget2D renderTarget,
+            PerspectiveCamera camera,
+            T drawable,
+            DepthStencilState depthStencilState
+        ) where T : IIndexDrawable {
+            GraphicsDevice.SetRenderTarget(renderTarget);
+            GraphicsDevice.DepthStencilState = depthStencilState;
+
+            SimpleDepthEffect.View = camera.View;
+            SimpleDepthEffect.Projection = camera.Projection;
+
+            RenderIndexed(GraphicsDevice, drawable, SimpleDepthEffect);
+        }
+
         public void RenderSkybox(
             RenderTarget2D renderTarget,
             PerspectiveCamera camera,
@@ -362,6 +436,7 @@ namespace Kav
             GraphicsDevice.BlendState = BlendState.Opaque;
 
             Deferred_GBufferEffect.HardwareInstancingEnabled = true;
+            Deferred_GBufferEffect.IsSprite = false;
 
             Deferred_GBufferEffect.Albedo = drawable.Albedo;
             Deferred_GBufferEffect.Metallic = drawable.Metallic;
@@ -409,6 +484,7 @@ namespace Kav
             GraphicsDevice.DepthStencilState = DepthStencilState.Default;
             GraphicsDevice.BlendState = BlendState.Opaque;
 
+            Deferred_GBufferEffect.IsSprite = false;
             Deferred_GBufferEffect.HardwareInstancingEnabled = false;
             Deferred_GBufferEffect.View = camera.View;
             Deferred_GBufferEffect.Projection = camera.Projection;
@@ -461,7 +537,8 @@ namespace Kav
             PointLight pointLight
         ) {
             GraphicsDevice.SetRenderTarget(renderTarget);
-            GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
+            GraphicsDevice.RasterizerState = RasterizerState.CullClockwise;
+            GraphicsDevice.DepthStencilState = DepthStencilState.None;
             GraphicsDevice.BlendState = BlendState.Additive;
 
             DeferredPointLightEffect.GPosition = gPosition;
@@ -474,11 +551,21 @@ namespace Kav
 
             DeferredPointLightEffect.PointLightPosition = pointLight.Position;
             DeferredPointLightEffect.PointLightColor =
-                pointLight.Color.ToVector3() * pointLight.Intensity;
+                pointLight.Color.ToVector3() * pointLight.Radius;
 
             DeferredPointLightEffect.FarPlane = 25f; // FIXME: magic value
 
-            RenderFullscreenEffect(DeferredPointLightEffect);
+            DeferredPointLightEffect.World =
+                Matrix.CreateScale(pointLight.Radius) *
+                Matrix.CreateTranslation(pointLight.Position);
+            DeferredPointLightEffect.View = camera.View;
+            DeferredPointLightEffect.Projection = camera.Projection;
+
+            RenderIndexed(
+                GraphicsDevice,
+                UnitSphere.Meshes[0].MeshParts[0],
+                DeferredPointLightEffect
+            );
         }
 
         public void RenderDirectionalLight(
@@ -492,6 +579,7 @@ namespace Kav
             DirectionalLight directionalLight
         ) {
             GraphicsDevice.SetRenderTarget(renderTarget);
+            GraphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
             GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
             GraphicsDevice.BlendState = BlendState.Additive;
 
@@ -737,7 +825,6 @@ namespace Kav
 
         public void RenderPointShadowMapIndexed<T>(
             RenderTargetCube pointShadowCubeMap,
-            PerspectiveCamera camera,
             IEnumerable<(T, Matrix)> modelTransforms,
             PointLight pointLight
         ) where T : ICullable, IIndexDrawable {
@@ -907,19 +994,27 @@ namespace Kav
             }
         }
 
-        private static IEnumerable<Matrix> FrustumCull<T>(
+        private static bool FrustumCull<T>(
             BoundingFrustum boundingFrustum,
             T cullable,
-            IEnumerable<Matrix> transforms
+            Matrix transform
-        ) where T : ICullable
+        ) where T : ICullable {
-        {
-            foreach (var transform in transforms)
-            {
             var boundingBox = TransformedBoundingBox(cullable.BoundingBox, transform);
             var containment = boundingFrustum.Contains(boundingBox);
+            return (containment == ContainmentType.Disjoint);
+        }
+
+        private static IEnumerable<T> FrustumCull<T>(
+            BoundingFrustum boundingFrustum,
+            IEnumerable<T> cullableTransformables
+        ) where T : ICullable, ITransformable {
+            foreach (var cullableTransformable in cullableTransformables)
+            {
+                var boundingBox = TransformedBoundingBox(cullableTransformable.BoundingBox, cullableTransformable.TransformMatrix);
+                var containment = boundingFrustum.Contains(boundingBox);
                 if (containment != ContainmentType.Disjoint)
                 {
-                    yield return transform;
+                    yield return cullableTransformable;
                 }
             }
         }

Resources.cs

@@ -195,6 +195,18 @@ namespace Kav
             }
         }
 
+        public static byte[] UnitSphereModel
+        {
+            get
+            {
+                if (unitSphereModel == null)
+                {
+                    unitSphereModel = GetResource("UnitSphere.glb");
+                }
+                return unitSphereModel;
+            }
+        }
+
         private static byte[] ambientLightEffect;
         private static byte[] pointLightEffect;
         private static byte[] directionalLightEffect;
@@ -212,6 +224,7 @@ namespace Kav
         private static byte[] paletteCrushEffect;
 
         private static byte[] unitCubeModel;
+        private static byte[] unitSphereModel;
 
         private static byte[] GetResource(string name)
         {