feat: enhance asset management with flexible path configuration and shader integration

Author: tomasforsman

samples/SampleGame/AssetDemo.cs

@@ -3,6 +3,7 @@
 using Rac.Engine;
 using Rac.Assets.Types;
 using Rac.Rendering;
+using Rac.Rendering.Shader;
 using Rac.Core.Manager;
 using Rac.Input.Service;
 using Silk.NET.Maths;
@@ -30,15 +31,14 @@ public class AssetDemo
     private IEngineFacade? _engine;
     private Texture? _sampleTexture;
     private AudioClip? _sampleAudio;
-    private IAssetService? _assetService;
 
-    // Square geometry for rendering
-    private readonly BasicVertex[] _squareVertices = new[]
+    // Square geometry for texture rendering with proper UV coordinates
+    private readonly TexturedVertex[] _squareVertices = new[]
     {
-        new BasicVertex(new Vector2D<float>(-100, -100)), // Bottom-left
-        new BasicVertex(new Vector2D<float>( 100, -100)), // Bottom-right
-        new BasicVertex(new Vector2D<float>( 100,  100)), // Top-right
-        new BasicVertex(new Vector2D<float>(-100,  100))  // Top-left
+        new TexturedVertex(new Vector2D<float>(-100, -100), new Vector2D<float>(0, 1)), // Bottom-left (UV: 0,1)
+        new TexturedVertex(new Vector2D<float>( 100, -100), new Vector2D<float>(1, 1)), // Bottom-right (UV: 1,1)
+        new TexturedVertex(new Vector2D<float>( 100,  100), new Vector2D<float>(1, 0)), // Top-right (UV: 1,0)
+        new TexturedVertex(new Vector2D<float>(-100,  100), new Vector2D<float>(0, 0))  // Top-left (UV: 0,0)
     };
 
     public static void Run(string[] args)
@@ -127,9 +127,7 @@ private void LoadAssets()
 
             // Load audio using Engine facade (recommended approach)
             Console.WriteLine("Loading SampleAudio.wav...");
-            var _path = Path.Combine(AppContext.BaseDirectory, "Assets");
-            var _fullPath = Path.Combine(_path, "SampleAudio.wav");
-            if (_engine != null) _sampleAudio = _engine.LoadAudio(_fullPath);
+            _sampleAudio = _engine.LoadAudio("SampleAudio.wav");
             Console.WriteLine($"✓ Audio loaded: {_sampleAudio.Duration:F2}s, {_sampleAudio.SampleRate}Hz, {_sampleAudio.Channels} channels, {_sampleAudio.MemorySize / 1024}KB");
 
             // Demonstrate asset service integration
@@ -191,6 +189,9 @@ private void OnRender(float deltaTime)
             // Clear the screen
             _engine.Renderer.Clear();
 
+            // Set shader mode for rendering (this was the missing piece!)
+            _engine.Renderer.SetShaderMode(ShaderMode.Normal);
+
             // Render textured square in the center of the screen
             if (_sampleTexture != null)
             {

samples/SampleGame/Program.cs

@@ -10,7 +10,8 @@ public static class Program
         ["camerademo"] = ("Interactive camera system demonstration with dual-camera rendering", CameraDemonstration.Run),
         ["pipelinedemo"] = ("Educational 4-phase rendering pipeline demonstration", RenderingPipelineDemo.Run),
         ["containersample"] = ("Container system demonstration with inventory and equipment patterns", ContainerSample.Run),
-        ["assetdemo"] = ("Assets system demonstration", AssetDemo.Run)
+        ["assetdemo"] = ("Assets system demonstration", AssetDemo.Run),
+        ["assetpathdemo"] = ("Asset path configuration demonstration", AssetPathDemo.Run)
     };
 
     public static void Main(string[] args)

src/Rac.Engine/EngineFacade.cs

@@ -14,6 +14,7 @@
 using Rac.Rendering.Camera;
 using Silk.NET.Input;
 using Silk.NET.Maths;
+using System.Collections.Concurrent;
 
 namespace Rac.Engine;
 
@@ -22,6 +23,9 @@ public class EngineFacade : IEngineFacade
     private readonly GameEngine.Engine _inner;
     private readonly IWindowManager _windowManager;
     private readonly TransformSystem _transformSystem;
+    private readonly ConcurrentDictionary<Type, FileAssetService> _assetServices = new();
+    private readonly Dictionary<Type, string> _assetTypePaths = new();
+    private string _defaultAssetBasePath;
 
     public EngineFacade(
         IWindowManager windowManager,
@@ -49,9 +53,12 @@ ConfigManager configManager
             Audio = new NullAudioService();
         }
 
+        // Initialize default asset base path
+        _defaultAssetBasePath = Path.Combine(AppContext.BaseDirectory, "Assets");
+
         // Initialize asset service with default configuration
         Assets = AssetServiceBuilder.Create()
-            .WithBasePath("Assets")
+            .WithBasePath(_defaultAssetBasePath)
             .Build();
 
         // Initialize transform system (required for container operations)
@@ -92,7 +99,7 @@ ConfigManager configManager
     public SystemScheduler Systems { get; }
     public IRenderer Renderer => _inner.Renderer;
     public IAudioService Audio { get; }
-    public IAssetService Assets { get; }
+    public IAssetService Assets { get; private set; }
     public ICameraManager CameraManager { get; }
     public IWindowManager WindowManager => _windowManager;
     public IContainerService Container { get; }
@@ -326,7 +333,7 @@ public Texture LoadTexture(string filename)
 
         try
         {
-            return Assets.LoadAsset<Texture>(filename);
+            return GetAssetServiceForType<Texture>().LoadAsset<Texture>(filename);
         }
         catch (FileNotFoundException)
         {
@@ -390,7 +397,7 @@ public AudioClip LoadAudio(string filename)
 
         try
         {
-            return Assets.LoadAsset<AudioClip>(filename);
+            return GetAssetServiceForType<AudioClip>().LoadAsset<AudioClip>(filename);
         }
         catch (FileNotFoundException)
         {
@@ -456,7 +463,7 @@ public string LoadShaderSource(string filename)
 
         try
         {
-            return Assets.LoadAsset<string>(filename);
+            return GetAssetServiceForType<string>().LoadAsset<string>(filename);
         }
         catch (FileNotFoundException)
         {
@@ -472,4 +479,209 @@ public string LoadShaderSource(string filename)
                 $"Ensure the file uses a supported text encoding (UTF-8 recommended).", ex);
         }
     }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // ASSET PATH CONFIGURATION METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /// <summary>
+    /// Sets the base path for all asset types (fallback for specific types).
+    /// 
+    /// EDUCATIONAL PURPOSE:
+    /// This method demonstrates flexible asset organization:
+    /// - Allows changing the default asset location at runtime
+    /// - Provides fallback path for asset types without specific configuration
+    /// - Recreates asset services to use the new path
+    /// - Maintains backward compatibility with existing code
+    /// </summary>
+    /// <param name="basePath">Base directory for asset files</param>
+    /// <exception cref="ArgumentNullException">Thrown when basePath is null</exception>
+    /// <example>
+    /// <code>
+    /// // Set all assets to load from "GameContent" folder
+    /// engine.SetAssetBasePath("GameContent");
+    /// 
+    /// // Set absolute path
+    /// engine.SetAssetBasePath(@"C:\MyGame\Assets");
+    /// </code>
+    /// </example>
+    public void SetAssetBasePath(string basePath)
+    {
+        if (basePath == null)
+            throw new ArgumentNullException(nameof(basePath));
+
+        _defaultAssetBasePath = Path.IsPathRooted(basePath) 
+            ? basePath 
+            : Path.Combine(AppContext.BaseDirectory, basePath);
+
+        RecreateAssetServices();
+    }
+
+    /// <summary>
+    /// Sets the base path specifically for audio assets.
+    /// 
+    /// EDUCATIONAL PURPOSE:
+    /// Type-specific asset organization enables better project structure:
+    /// - Audio files can be organized in dedicated folders
+    /// - Different asset types can have different storage strategies
+    /// - Fallback to default path ensures compatibility
+    /// - Runtime configuration allows flexible deployment
+    /// </summary>
+    /// <param name="basePath">Base directory for audio asset files</param>
+    /// <exception cref="ArgumentNullException">Thrown when basePath is null</exception>
+    /// <example>
+    /// <code>
+    /// // Audio files in "Audio" folder
+    /// engine.SetAudioBasePath("Audio");
+    /// 
+    /// // Then load audio normally
+    /// var sound = engine.LoadAudio("jump.wav"); // Loads from Audio/jump.wav
+    /// </code>
+    /// </example>
+    public void SetAudioBasePath(string basePath)
+    {
+        if (basePath == null)
+            throw new ArgumentNullException(nameof(basePath));
+
+        var fullPath = Path.IsPathRooted(basePath) 
+            ? basePath 
+            : Path.Combine(AppContext.BaseDirectory, basePath);
+
+        _assetTypePaths[typeof(AudioClip)] = fullPath;
+        RecreateAssetServiceForType<AudioClip>();
+    }
+
+    /// <summary>
+    /// Sets the base path specifically for texture assets.
+    /// 
+    /// EDUCATIONAL PURPOSE:
+    /// Texture-specific organization demonstrates asset categorization:
+    /// - Visual assets often have different storage requirements
+    /// - Texture files can be large and benefit from dedicated organization
+    /// - Separate paths enable different caching strategies
+    /// - Artist-friendly folder structures improve workflow
+    /// </summary>
+    /// <param name="basePath">Base directory for texture asset files</param>
+    /// <exception cref="ArgumentNullException">Thrown when basePath is null</exception>
+    /// <example>
+    /// <code>
+    /// // Texture files in "Textures" folder
+    /// engine.SetTextureBasePath("Textures");
+    /// 
+    /// // Then load textures normally
+    /// var texture = engine.LoadTexture("player.png"); // Loads from Textures/player.png
+    /// </code>
+    /// </example>
+    public void SetTextureBasePath(string basePath)
+    {
+        if (basePath == null)
+            throw new ArgumentNullException(nameof(basePath));
+
+        var fullPath = Path.IsPathRooted(basePath) 
+            ? basePath 
+            : Path.Combine(AppContext.BaseDirectory, basePath);
+
+        _assetTypePaths[typeof(Texture)] = fullPath;
+        RecreateAssetServiceForType<Texture>();
+    }
+
+    /// <summary>
+    /// Sets the base path specifically for text assets (shaders, configs, etc.).
+    /// 
+    /// EDUCATIONAL PURPOSE:
+    /// Text asset organization enables data-driven development:
+    /// - Shader files can be organized separately from other assets
+    /// - Configuration files can have dedicated storage
+    /// - Text assets often have different versioning requirements
+    /// - Enables separate processing pipelines for different text types
+    /// </summary>
+    /// <param name="basePath">Base directory for text asset files</param>
+    /// <exception cref="ArgumentNullException">Thrown when basePath is null</exception>
+    /// <example>
+    /// <code>
+    /// // Text files in "Data" folder
+    /// engine.SetTextBasePath("Data");
+    /// 
+    /// // Then load text assets normally
+    /// var shader = engine.LoadShaderSource("basic.vert"); // Loads from Data/basic.vert
+    /// </code>
+    /// </example>
+    public void SetTextBasePath(string basePath)
+    {
+        if (basePath == null)
+            throw new ArgumentNullException(nameof(basePath));
+
+        var fullPath = Path.IsPathRooted(basePath) 
+            ? basePath 
+            : Path.Combine(AppContext.BaseDirectory, basePath);
+
+        _assetTypePaths[typeof(string)] = fullPath;
+        RecreateAssetServiceForType<string>();
+    }
+
+    /// <summary>
+    /// Recreates all asset services to use updated base paths.
+    /// Educational note: Ensures all services use current path configuration.
+    /// </summary>
+    private void RecreateAssetServices()
+    {
+        // Dispose existing services
+        foreach (var service in _assetServices.Values)
+        {
+            service.Dispose();
+        }
+        _assetServices.Clear();
+
+        // Recreate main asset service
+        if (Assets is IDisposable disposableAssets)
+        {
+            disposableAssets.Dispose();
+        }
+        Assets = AssetServiceBuilder.Create()
+            .WithBasePath(_defaultAssetBasePath)
+            .Build();
+    }
+
+    /// <summary>
+    /// Recreates the asset service for a specific type.
+    /// Educational note: Selective recreation minimizes impact on other asset types.
+    /// </summary>
+    private void RecreateAssetServiceForType<T>() where T : class
+    {
+        var type = typeof(T);
+        
+        if (_assetServices.TryRemove(type, out var existingService))
+        {
+            existingService.Dispose();
+        }
+
+        // The service will be recreated lazily when needed
+    }
+
+    /// <summary>
+    /// Gets the appropriate asset service for the specified type.
+    /// Educational note: Lazy initialization with type-specific path resolution.
+    /// </summary>
+    private IAssetService GetAssetServiceForType<T>() where T : class
+    {
+        var type = typeof(T);
+
+        if (_assetServices.TryGetValue(type, out var existingService))
+        {
+            return existingService;
+        }
+
+        // Determine base path for this type
+        var basePath = _assetTypePaths.TryGetValue(type, out var specificPath) 
+            ? specificPath 
+            : _defaultAssetBasePath;
+
+        // Create service for this type
+        var service = AssetServiceBuilder.Create()
+            .WithBasePath(basePath)
+            .Build();
+
+        _assetServices[type] = service;
+        return service;
+    }
 }