refactor(render): Refactor rendering engine to support animated images and optimize resource management

- Standardize on the IList interface in Drawer and refactor data models to simplify template variables
- Add image caching to AssetProvider and optimize resource path resolution logic
- Implement animation metadata inheritance in NodeRenderer to support GIF/PNG/WEBP animation frames
- Remove hardcoded image resizing logic from ServerStreamWriterExtensions
- Refactor TemplateReader expression evaluation and remove redundant EvaluateSetValueAsync method
- Fix null reference issue in asynchronous function evaluation within AsyncNCalcEngine
- Add measurement support for ResizedNode to improve the node rendering system

Author: Yushu2606

src/Render/AssetProvider.cs

@@ -8,6 +8,7 @@ namespace Limekuma.Render;
 
 public sealed class AssetProvider
 {
+    private readonly ConcurrentDictionary<string, Image> _assets;
     private readonly ConcurrentDictionary<string, LoadedFont> _fontCache;
     private readonly Dictionary<string, (string, List<string>?)> _fontRules;
     private readonly Dictionary<string, (string, string?)> _pathRules;
@@ -20,6 +21,7 @@ public AssetProvider(string resourcePath)
     {
         _fontRules = [];
         _pathRules = [];
+        _assets = [];
         _fontCache = [];
         LoadResources(resourcePath);
     }
@@ -29,7 +31,7 @@ public AssetProvider(string resourcePath)
     public Image LoadImage(string ns, string key)
     {
         string path = ResolveResourcePath(ns, key);
-        return Image.Load(path);
+        return LoadImage(path);
     }
 
     public (FontFamily, List<FontFamily>) ResolveFont(string key)
@@ -55,7 +57,7 @@ public Size Measure(string text, string family, float size)
         (FontFamily fontFamily, List<FontFamily> fallbacks) = ResolveFont(family);
         float scaledSize = (float)(size * 72 / 300d);
         Font font = fontFamily.CreateFont(scaledSize);
-        FontRectangle rect = TextMeasurer.MeasureAdvance(text, new TextOptions(font)
+        FontRectangle rect = TextMeasurer.MeasureAdvance(text, new(font)
         {
             FallbackFontFamilies = fallbacks,
             Dpi = 300
@@ -71,7 +73,7 @@ public Size Measure(string text, string family, float size)
         }
 
         (string path, _) = pathRule;
-        return Path.GetFullPath(path);
+        return path;
     }
 
     private void LoadResources(string resourcePath)
@@ -103,7 +105,7 @@ private void LoadPathRules(XElement resourcesNode)
                 continue;
             }
 
-            _pathRules[ns] = new(Path.GetFullPath(path), node.Attribute("rule")?.Value);
+            _pathRules[ns] = new(path, node.Attribute("rule")?.Value);
         }
     }
 
@@ -140,7 +142,7 @@ private string ResolveResourcePath(string ns, string key)
     {
         if (!_pathRules.TryGetValue(ns, out (string, string?) pathRule))
         {
-            return Path.GetFullPath(key);
+            return key;
         }
 
         (string path, string? rule) = pathRule;
@@ -152,10 +154,20 @@ private string ResolveResourcePath(string ns, string key)
         return Path.Combine(path, Smart.Format(rule, new { key }));
     }
 
+    private Image LoadImage(string path)
+    {
+        Image loaded = _assets.GetOrAdd(path, p =>
+        {
+            Image image = Image.Load(path);
+            return image;
+        });
+
+        return loaded;
+    }
+
     private FontFamily LoadFont(string path)
     {
-        string fullPath = Path.GetFullPath(path);
-        LoadedFont loaded = _fontCache.GetOrAdd(fullPath, p =>
+        LoadedFont loaded = _fontCache.GetOrAdd(path, p =>
         {
             FontCollection collection = new();
             FontFamily family = collection.Add(p);

src/Render/Drawer.cs

@@ -2,67 +2,47 @@
 using Limekuma.Render.ExpressionEngine;
 using Limekuma.Render.Nodes;
 using SixLabors.ImageSharp;
+using System.Collections;
 
 namespace Limekuma.Render;
 
 public sealed class Drawer
 {
-    public async Task<Image> DrawBestsAsync(CommonUser user, IEnumerable<CommonRecord> ever,
-        IEnumerable<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober) =>
+    public async Task<Image> DrawBestsAsync(CommonUser user, IList<CommonRecord> ever,
+        IList<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober) =>
         await DrawBestsAsync(user, ever, current, everTotal, currentTotal, typename, prober, false, false);
 
-    public async Task<Image> DrawBestsAsync(CommonUser user, IEnumerable<CommonRecord> ever,
-        IEnumerable<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober,
+    public async Task<Image> DrawBestsAsync(CommonUser user, IList<CommonRecord> ever,
+        IList<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober,
         bool isAnime) =>
         await DrawBestsAsync(user, ever, current, everTotal, currentTotal, typename, prober, isAnime, false);
 
-    public async Task<Image> DrawBestsAsync(CommonUser user, IEnumerable<CommonRecord> ever,
-        IEnumerable<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober,
+    public async Task<Image> DrawBestsAsync(CommonUser user, IList<CommonRecord> ever,
+        IList<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober,
         bool isAnime, bool drawLevelSeg) => await DrawBestsAsync(user, ever, current, everTotal, currentTotal, typename,
         prober, isAnime, drawLevelSeg, "./Resources/Layouts/bests.xml");
 
-    public async Task<Image> DrawBestsAsync(CommonUser user, IEnumerable<CommonRecord> ever,
-        IEnumerable<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober,
+    public async Task<Image> DrawBestsAsync(CommonUser user, IList<CommonRecord> ever,
+        IList<CommonRecord> current, int everTotal, int currentTotal, string typename, string prober,
         bool isAnime, bool drawLevelSeg, string xmlPath)
     {
-        List<CommonRecord> everList = [.. ever];
-        List<CommonRecord> currentList = [.. current];
-        List<object> everCards = [.. everList.Select((record, idx) => new { Record = record, Index = idx + 1 })];
-        List<object> currentCards =
-            [.. currentList.Select((record, idx) => new { Record = record, Index = idx + everList.Count + 1 })];
-        int everDelta = everList.Count > 34 ? everList[0].DXRating - everList[^1].DXRating : everList.Count > 0 ? everList[0].DXRating : 0;
-        int currentDelta = currentList.Count > 14 ? currentList[0].DXRating - currentList[^1].DXRating : currentList.Count > 0 ? currentList[0].DXRating : 0;
-        int everMax = everList.Count > 0 ? everList[0].DXRating : 0;
-        int everMin = everList.Count > 0 ? everList[^1].DXRating : 0;
-        int currentMax = currentList.Count > 0 ? currentList[0].DXRating : 0;
-        int currentMin = currentList.Count > 0 ? currentList[^1].DXRating : 0;
-        int realRating = everTotal + currentTotal;
-        string proberState = "on";
-        if (user.Rating != realRating)
+        int everMax = ever.Count > 0 ? ever[0].DXRating : 0;
+        int everMin = ever.Count > 0 ? ever[^1].DXRating : 0;
+        int currentMax = current.Count > 0 ? current[0].DXRating : 0;
+        int currentMin = current.Count > 0 ? current[^1].DXRating : 0;
+        bool mayMask = ever.Any(r => r.DXScore is 0 && (r.DXStar > 0 || r.Rank > Ranks.A)) || current.Any(r => r.DXScore is 0 && (r.DXStar > 0 || r.Rank > Ranks.A));
+        Dictionary<string, object> scope = new(StringComparer.OrdinalIgnoreCase)
         {
-            proberState = "off";
-        }
-        else if (everList.Any(r => r.DXScore is 0 && (r.DXStar > 0 || r.Rank < Ranks.C)) ||
-                 currentList.Any(r => r.DXScore is 0 && (r.DXStar > 0 || r.Rank < Ranks.C)))
-        {
-            proberState = "warning";
-        }
-
-        Dictionary<string, object?> scope = new(StringComparer.OrdinalIgnoreCase)
-        {
-            ["user"] = user,
-            ["everCards"] = everCards,
-            ["currentCards"] = currentCards,
-            ["everDelta"] = everDelta,
-            ["currentDelta"] = currentDelta,
-            ["everTotal"] = everTotal,
-            ["currentTotal"] = currentTotal,
-            ["realRating"] = realRating,
-            ["typename"] = typename,
-            ["prober"] = prober,
-            ["isAnime"] = isAnime,
-            ["drawLevelSeg"] = drawLevelSeg,
-            ["proberState"] = proberState,
+            ["userInfo"] = user,
+            ["everRecords"] = ever,
+            ["currentRecords"] = current,
+            ["everRating"] = everTotal,
+            ["currentRating"] = currentTotal,
+            ["typeName"] = typename,
+            ["proberName"] = prober,
+            ["animeMode"] = isAnime,
+            ["needSuggestion"] = drawLevelSeg,
+            ["mayMask"] = mayMask,
             ["everMax"] = everMax,
             ["everMin"] = everMin,
             ["currentMax"] = currentMax,
@@ -71,35 +51,33 @@ public async Task<Image> DrawBestsAsync(CommonUser user, IEnumerable<CommonRecor
         return await DrawAsync(scope, xmlPath);
     }
 
-    public async Task<Image> DrawListAsync(CommonUser user, IEnumerable<CommonRecord> records, int page, int total,
-        IEnumerable<int> counts, string level, string prober) => await DrawListAsync(user, records, page, total, counts,
-        level, prober, "./Resources/Layouts/list.xml");
+    public async Task<Image> DrawListAsync(CommonUser user, IList<CommonRecord> records, int page, int total,
+        IList<int> counts, int startIndex, string level, string prober) => await DrawListAsync(user, records, page, total, counts,
+        startIndex, level, prober, "./Resources/Layouts/list.xml");
 
-    public async Task<Image> DrawListAsync(CommonUser user, IEnumerable<CommonRecord> records, int page, int total,
-        IEnumerable<int> counts, string level, string prober, string xmlPath)
+    public async Task<Image> DrawListAsync(CommonUser user, IList<CommonRecord> records, int page, int total,
+        IList<int> counts, int startIndex, string level, string prober, string xmlPath)
     {
-        List<CommonRecord> list = [.. records];
-        List<object> recordCards = [.. list.Select((record, idx) => new { Record = record, Index = idx + 1 })];
-        List<int> countList = counts.ToList();
-        int totalCount = countList.Count > 0 ? countList[^1] : 0;
-        bool warning = list.Any(r => r.DXScore is 0 && (r.DXStar > 0 || r.Rank < Ranks.C));
-        Dictionary<string, object?> scope = new(StringComparer.OrdinalIgnoreCase)
+        int totalCount = counts.Count > 0 ? counts[^1] : 0;
+        bool mayMask = records.Any(r => r.DXScore is 0 && (r.DXStar > 0 || r.Rank > Ranks.A));
+        Dictionary<string, object> scope = new(StringComparer.OrdinalIgnoreCase)
         {
-            ["user"] = user,
-            ["recordCards"] = recordCards,
-            ["page"] = page,
-            ["total"] = total,
-            ["counts"] = countList[..^1],
-            ["statsTotalCount"] = totalCount,
+            ["userInfo"] = user,
+            ["pageRecords"] = records,
+            ["pageNumber"] = page,
+            ["totalPages"] = total,
+            ["statCounts"] = counts.ToList()[..^1],
+            ["totalCount"] = totalCount,
+            ["startIndex"] = startIndex,
             ["level"] = level,
-            ["prober"] = prober,
-            ["proberState"] = warning ? "warning" : "on",
-            ["isAnime"] = false,
+            ["proberName"] = prober,
+            ["mayMask"] = mayMask,
+            ["animeMode"] = false,
         };
         return await DrawAsync(scope, xmlPath);
     }
 
-    private async Task<Image> DrawAsync(Dictionary<string, object?> scope, string xmlPath)
+    private async Task<Image> DrawAsync(IDictionary<string, object> scope, string xmlPath)
     {
         AsyncNCalcEngine expr = new();
         RegisterFunctions(expr);
@@ -112,5 +90,6 @@ private async Task<Image> DrawAsync(Dictionary<string, object?> scope, string xm
     private void RegisterFunctions(AsyncNCalcEngine expr)
     {
         expr.RegisterFunction("ToString", (object x) => Convert.ToString(x));
+        expr.RegisterFunction("Count", (IList x) => x.Count);
     }
 }

src/Render/ExpressionEngine/AsyncNCalcEngine.cs

@@ -52,20 +52,22 @@ public sealed class AsyncNCalcEngine
         }
         expression.EvaluateFunctionAsync += async (name, args) =>
         {
-            if (_functions.TryGetValue(name, out Delegate? func))
+            if (!_functions.TryGetValue(name, out Delegate? func))
             {
-                ParameterInfo[] parameters = func.Method.GetParameters();
-                object?[] funcArgs = new object[args.Parameters.Length];
-                for (int i = 0; i < args.Parameters.Length; ++i)
-                {
-                    object? paramValue = await args.Parameters[i].EvaluateAsync();
-                    funcArgs[i] = CoerceValue(paramValue,
-                        i < parameters.Length ? parameters[i].ParameterType : typeof(object));
-                }
+                return;
+            }
 
-                object? result = func.DynamicInvoke(funcArgs);
-                args.Result = result;
+            ParameterInfo[] parameters = func.Method.GetParameters();
+            object?[] funcArgs = new object[args.Parameters.Length];
+            for (int i = 0; i < args.Parameters.Length; ++i)
+            {
+                object? paramValue = await args.Parameters[i].EvaluateAsync();
+                funcArgs[i] = CoerceValue(paramValue,
+                    i < parameters.Length ? parameters[i].ParameterType : typeof(object));
             }
+
+            object? result = func.DynamicInvoke(funcArgs);
+            args.Result = result;
         };
 
         return await expression.EvaluateAsync();

src/Render/NodeRenderer.Measurement.cs

@@ -10,6 +10,7 @@ public static partial class NodeRenderer
     {
         ImageNode image => MeasureImageNode(image, assets),
         TextNode text => MeasureTextNode(text, measurer),
+        ResizedNode resized => MeasureResizedNode(resized, assets, measurer),
         StackNode stack => MeasureStackNode(stack, assets, measurer),
         GridNode grid => MeasureGridNode(grid, assets, measurer),
         LayerNode layer => MeasureLayerNode(layer, assets, measurer),
@@ -20,13 +21,21 @@ public static partial class NodeRenderer
 
     private static Size MeasureImageNode(ImageNode image, AssetProvider assets)
     {
-        using Image img = assets.LoadImage(image.Namespace, image.ResourceKey);
+        Image img = assets.LoadImage(image.Namespace, image.ResourceKey);
         return new(img.Width, img.Height);
     }
 
     private static Size MeasureTextNode(TextNode text, AssetProvider measurer) =>
         measurer.Measure(text.Text, text.FontFamily, text.FontSize);
 
+    private static Size MeasureResizedNode(ResizedNode resized, AssetProvider assets, AssetProvider measurer)
+    {
+        Size baseSize = resized.DesiredSize ?? Measure(resized.Child, assets, measurer);
+        int width = Math.Max(1, (int)Math.Round(baseSize.Width * resized.Scale));
+        int height = Math.Max(1, (int)Math.Round(baseSize.Height * resized.Scale));
+        return new(width, height);
+    }
+
     private static Size MeasureStackNode(StackNode stack, AssetProvider assets, AssetProvider measurer)
     {
         List<Node> flowChildren = ExpandFlowChildren(stack.Children);
@@ -116,4 +125,4 @@ private static List<Node> ExpandFlowChildren(IEnumerable<Node> children)
 
         return output;
     }
-}
+}