Add asset pipeline and Shader importer

Author: chances

Engine/Assets/AssetDataLoader.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using JetBrains.Annotations;
+using LiteGuard;
+
+namespace Engine.Assets
+{
+    public class AssetDataLoader
+    {
+        private readonly Assembly _gameAssembly;
+        private readonly Dictionary<AssetType, string> _assetDirectoryPaths;
+        private readonly string[] _assetFilenames;
+
+        public AssetDataLoader(Assembly gameAssembly, Dictionary<AssetType, string> assetDirectoryPaths)
+        {
+            _gameAssembly = gameAssembly;
+            _assetDirectoryPaths = assetDirectoryPaths;
+            _assetFilenames = gameAssembly.GetManifestResourceNames();
+        }
+
+        /// <summary>
+        /// Load an asset from the asset library given a <paramref name="type"/> and a <paramref name="filename"/>.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="filename"></param>
+        /// <returns><see cref="Stream"/> of loaded asset's data</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="filename"/> is null</exception>
+        /// <exception cref="InvalidOperationException">Asset type doesn't exist in asset directory dictionary</exception>
+        /// <exception cref="FileNotFoundException">Given <paramref name="filename"/> doesn't exist in asset library</exception>
+        public Stream Load(AssetType type, [NotNull] string filename)
+        {
+            Guard.AgainstNullArgument(nameof(filename), filename);
+            if (!_assetDirectoryPaths.ContainsKey(type))
+            {
+                throw new InvalidOperationException($"{type} does not exist in the asset directory path dictionary");
+            }
+
+            var assetFilePath = $"{_assetDirectoryPaths[type]}.{filename}";
+
+            if (!_assetFilenames.Contains(assetFilePath))
+            {
+                throw new FileNotFoundException($"{filename} not found in asset library");
+            }
+
+            return _gameAssembly.GetManifestResourceStream(assetFilePath);
+        }
+    }
+}

Engine/Assets/AssetType.cs

@@ -0,0 +1,8 @@
+namespace Engine.Assets
+{
+    public enum AssetType
+    {
+        Model,
+        Shader
+    }
+}

Engine/Assets/IAssetImporter.cs

@@ -0,0 +1,9 @@
+using System.IO;
+
+namespace Engine.Assets
+{
+    public interface IAssetImporter<out T>
+    {
+        T Import(Stream assetData);
+    }
+}

Engine/Assets/ShaderImporter.cs

@@ -0,0 +1,19 @@
+using System.IO;
+
+namespace Engine.Assets
+{
+    public class ShaderImporter : IAssetImporter<byte[]>
+    {
+        public static ShaderImporter Instance = new ShaderImporter();
+
+        public byte[] Import(Stream assetData)
+        {
+            using (var stream = new MemoryStream())
+            {
+                // TODO: User CopyToAsync when we need "Loading..." screen
+                assetData.CopyTo(stream);
+                return stream.ToArray();
+            }
+        }
+    }
+}

Engine/Components/IAsset.cs

@@ -0,0 +1,9 @@
+using Engine.Assets;
+
+namespace Engine.Components
+{
+    public interface IAsset
+    {
+        void LoadAssets(AssetDataLoader assetDataLoader);
+    }
+}

Engine/Components/Material.cs

@@ -1,25 +1,23 @@
+using Engine.Assets;
 using Engine.ECS;
 using Veldrid;
+using Veldrid.SPIRV;
 
 namespace Engine.Components
 {
-    public class Material : Component, IResource
+    public class Material : Component, IResource, IAsset
     {
-        private readonly byte[] _shaderSource;
-        private Shader _vertexShader;
-        private Shader _fragmentShader;
+        private ResourceFactory _factory;
 
         public Material(
             string name,
-            byte[] shaderSource,
             string shaderFilename,
             BlendStateDescription blendState,
             DepthStencilStateDescription depthStencilState,
             PolygonFillMode fillMode = PolygonFillMode.Solid,
             bool depthClipEnabled = true)
             : base(name)
         {
-            _shaderSource = shaderSource;
             ShaderFilename = shaderFilename;
             DepthStencilState = depthStencilState;
             FillMode = fillMode;
@@ -31,28 +29,32 @@ public Material(
             depthTestEnabled: true, depthWriteEnabled: true, comparisonKind: ComparisonKind.LessEqual);
 
         public string ShaderFilename { get; }
-        public Shader[] Shaders => new Shader[] {_vertexShader, _fragmentShader};
+        public Shader[] Shaders { get; private set; }
         public DepthStencilStateDescription DepthStencilState { get; }
         public PolygonFillMode FillMode { get; }
         public bool DepthClipEnabled { get; }
         public BlendStateDescription BlendState { get; }
 
         public void Initialize(ResourceFactory factory, GraphicsDevice device)
         {
-            // Compile shaders
-            _vertexShader = CompileShader(factory, ShaderStages.Vertex);
-            _fragmentShader = CompileShader(factory, ShaderStages.Fragment);
+            _factory = factory;
         }
 
-        public void Dispose()
+        public void LoadAssets(AssetDataLoader assetDataLoader)
         {
-            throw new System.NotImplementedException();
+            var shaderSource = ShaderImporter.Instance.Import(assetDataLoader.Load(AssetType.Shader, ShaderFilename));
+            // Compile shaders
+            Shaders = _factory.CreateFromSpirv(
+                new ShaderDescription(ShaderStages.Vertex, shaderSource, "VS"),
+                new ShaderDescription(ShaderStages.Fragment, shaderSource, "FS"));
         }
 
-        private Shader CompileShader(ResourceFactory factory, ShaderStages stage)
+        public void Dispose()
         {
-            var entryPoint = stage == ShaderStages.Vertex ? "VS" : "FS";
-            return factory.CreateShader(new ShaderDescription(stage, _shaderSource, entryPoint));
+            foreach (var shader in Shaders)
+            {
+                shader.Dispose();
+            }
         }
     }
 }

Engine/Game.cs

@@ -1,7 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using Engine.Components;
+using System.Reflection;
+using Engine.Assets;
 using Engine.ECS;
 using Engine.Input;
 using Engine.Systems;
@@ -11,13 +12,16 @@ namespace Engine
 {
     public abstract class Game : IDisposable
     {
+        private readonly AssetDataLoader _assetDataLoader;
         private readonly FrameTimeAverager _frameTimeAverager = new FrameTimeAverager(0.666);
 
         protected Game()
         {
             World = new World();
             LimitFrameRate = true;
             DesiredFrameLengthSeconds = 1.0 / 60.0;
+
+            _assetDataLoader = new AssetDataLoader(Assembly.GetCallingAssembly(), AssetDirectoryPaths);
         }
 
         private GameTime _gameTime;
@@ -35,6 +39,8 @@ protected Game()
         public ResourceFactory ResourceFactory => GraphicsDevice.ResourceFactory;
         public Framebuffer Framebuffer => GraphicsDevice.SwapchainFramebuffer;
 
+        public Dictionary<AssetType, string> AssetDirectoryPaths { get; } = new Dictionary<AssetType, string>();
+
         private TimeSpan TotalElapsedTime => _gameTime?.TotalGameTime ?? TimeSpan.Zero;
 
         protected abstract GraphicsDevice CreateGraphicsDevice();
@@ -45,6 +51,7 @@ private void InternalInitialize()
         {
             // Initialize all world resources
             new ResourceInitializer(World, ResourceFactory, GraphicsDevice).Operate();
+            new ComponentAssetLoader(World, _assetDataLoader).Operate();
         }
 
         public void Run()

Engine/Systems/ComponentAssetLoader.cs

@@ -0,0 +1,24 @@
+using Engine.Assets;
+using Engine.Components;
+using Engine.ECS;
+
+namespace Engine.Systems
+{
+    public class ComponentAssetLoader : System<IAsset>
+    {
+        private readonly AssetDataLoader _assetDataLoader;
+
+        public ComponentAssetLoader(World world, AssetDataLoader assetDataLoader) : base(world)
+        {
+            _assetDataLoader = assetDataLoader;
+        }
+
+        public override void Operate()
+        {
+            foreach (var asset in OperableComponents)
+            {
+                asset.LoadAssets(_assetDataLoader);
+            }
+        }
+    }
+}

Game/Game.cs

@@ -3,6 +3,7 @@
 using System.Runtime.InteropServices;
 using System.Text;
 using Engine;
+using Engine.Assets;
 using Engine.Components;
 using Engine.Entities;
 using Veldrid;
@@ -54,6 +55,8 @@ protected override GraphicsDevice CreateGraphicsDevice()
 
         protected override void Initialize()
         {
+            AssetDirectoryPaths.Add(AssetType.Shader, "Game.Content.Shaders");
+
             World.Add(EntityFactory.Create<Camera>());
 
             _commandList = ResourceFactory.CreateCommandList();