better drawing chain

Author: Cn-mjt44

1.3/Assemblies/RW_NodeTree.dll

@@ -4,18 +4,24 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using UnityEngine;
+using UnityEngine.Experimental.Rendering;
 using Verse;
 
 namespace RW_NodeTree
 {
     public class Graphic_ChildNode : Graphic
     {
-        public Graphic_ChildNode(INodeProcesser proccesser, Action<RenderTexture>? PostFX = null)
+        public Graphic_ChildNode(INodeProcesser proccesser, uint textureSizeFactor = RenderingTools.DefaultTextureSizeFactor, float exceedanceFactor = 1f, float exceedanceOffset = 1f, GraphicsFormat textureFormat = GraphicsFormat.R8G8B8A8_SRGB, FilterMode textureFilterMode = FilterMode.Bilinear, Action<RenderTexture>? PostFX = null)
         {
             if (proccesser == null) throw new ArgumentNullException(nameof(proccesser));
             if (proccesser is not Thing) throw new ArgumentException("Invalid processer type", nameof(proccesser));
             currentProcesser = proccesser;
             postFX = PostFX;
+            this.textureSizeFactor = textureSizeFactor;
+            this.exceedanceFactor = exceedanceFactor;
+            this.exceedanceOffset = exceedanceOffset;
+            this.textureFormat = textureFormat;
+            this.textureFilterMode = textureFilterMode;
             //base.drawSize = _THING.DrawSize(_THING.parent.Rotation);
             //base.data = _GRAPHIC.data;
         }
@@ -48,10 +54,19 @@ public override Material MatAt(Rot4 rot, Thing? thing = null)
 
             if (needUpdate || material == null || texture == null || cachedRenderTarget == null)
             {
-                currentProcesser.ChildNodes.GetNodeRenderingResult(rot, ref cachedRenderTarget, ref texture, this, postFX);
+                Dictionary<string, List<RenderInfo>> nodeRenderingInfos = currentProcesser.ChildNodes.GetNodeRenderingInfos(rot, this);
+
+                List<RenderInfo> final = new List<RenderInfo>();
+                foreach (var infos in nodeRenderingInfos)
+                {
+                    if (!infos.Value.NullOrEmpty()) final.AddRange(infos.Value);
+                }
+
+                RenderingTools.RenderToTarget(final, ref cachedRenderTarget, ref texture, textureFormat, default, textureSizeFactor, exceedanceFactor, exceedanceOffset, postFX);
+                
                 Shader shader = thing.DefaultGraphic.Shader;
                 texture!.wrapMode = TextureWrapMode.Clamp;
-                texture.filterMode = currentProcesser.TextureFilterMode;
+                texture.filterMode = textureFilterMode;
 
                 if (material == null)
                 {
@@ -65,10 +80,16 @@ public override Material MatAt(Rot4 rot, Thing? thing = null)
                 defaultRenderingCache[rot] = (false, material, texture, cachedRenderTarget);
             }
 
-            drawSize = new Vector2(texture.width, texture.height) / currentProcesser.TextureSizeFactor;
+            drawSize = new Vector2(texture.width, texture.height) / textureSizeFactor;
             return material;
         }
 
+        public override Mesh MeshAt(Rot4 rot)
+        {
+            MatAt(rot);
+            return base.MeshAt(rot);
+        }
+
         public override void DrawWorker(Vector3 loc, Rot4 rot, ThingDef? thingDef, Thing? thing, float extraRotation)
         {
             MatAt(rot);
@@ -174,8 +195,14 @@ private class OffScreenRenderingCache
             public RenderTexture? cachedRenderTargetNorth, cachedRenderTargetEast, cachedRenderTargetSouth, cachedRenderTargetWest;
         }
 
-        private readonly INodeProcesser currentProcesser;
-        private readonly Action<RenderTexture>? postFX;
+
+        public readonly uint textureSizeFactor;
+        public readonly float exceedanceFactor;
+        public readonly float exceedanceOffset;
+        public readonly GraphicsFormat textureFormat;
+        public readonly FilterMode textureFilterMode;
+        public readonly INodeProcesser currentProcesser;
+        public readonly Action<RenderTexture>? postFX;
         private readonly OffScreenRenderingCache defaultRenderingCache = new OffScreenRenderingCache();
     }
 }

1.4/Assemblies/RW_NodeTree.dll

@@ -9,15 +9,6 @@ namespace RW_NodeTree
 {
     public partial interface INodeProcesser : IThingHolder
     {
-        uint TextureSizeFactor { get; }
-
-        float ExceedanceFactor { get; }
-
-        float ExceedanceOffset { get; }
-
-        GraphicsFormat TextureFormat { get; }
-
-        FilterMode TextureFilterMode { get; }
 
         /// <summary>
         /// node container

1.5/Assemblies/RW_NodeTree.dll

@@ -367,30 +367,13 @@ public void CachedRootNodeNeedUpdate()
         }
 
 
-        public void GetNodeRenderingResult(Rot4 rot, ref RenderTexture? cachedRenderTarget, ref Texture2D? target, Graphic_ChildNode invokeSource, Action<RenderTexture>? PostFX = null)
+        internal Dictionary<string, List<RenderInfo>> GetNodeRenderingInfos(Rot4 rot, Graphic_ChildNode invokeSource)
         {
             UpdateNode();
             if (!UnityData.IsInMainThread) throw new InvalidOperationException("not in main thread");
             Dictionary<string, List<RenderInfo>> nodeRenderingInfos = new Dictionary<string, List<RenderInfo>>(Count + 1);
             Thing parent = (Thing)Processer;
 
-            //if (Prefs.DevMode)
-            //{
-            //    StackTrace stack = new StackTrace();
-            //    string stackReport = "";
-            //    for(int i =0; i < 8; i++)
-            //    {
-            //        StackFrame sf = stack.GetFrame(i);
-            //        MethodBase method = sf.GetMethod();
-            //        stackReport += method.DeclaringType + " -> " + method + " " + sf + "\n";
-            //    }
-            //    Log.Message(parent + " graphic : " + parent.Graphic + ";\nstack : " + stackReport);
-            //}
-
-
-            //ORIGIN
-
-
             Dictionary<string, object?> cachingData = new Dictionary<string, object?>();
 
             HashSet<string>? ChildForDraw = null;
@@ -413,36 +396,45 @@ public void GetNodeRenderingResult(Rot4 rot, ref RenderTexture? cachedRenderTarg
                     Thing? child = this[id];
                     if (child != null && id != null)
                     {
-                        RenderingTools.StartOrEndDrawCatchingBlock = true;
-                        try
+                        INodeProcesser? childProcesser = child as INodeProcesser;
+                        if(childProcesser != null)
                         {
-                            Rot4 rotCache = child.Rotation;
-                            child.Rotation = new Rot4((rot.AsInt + rotCache.AsInt) & 3);
-#if V13 || V14
-                            child.DrawAt(Vector3.zero);
-#else
-                            child.DrawNowAt(Vector3.zero);
-#endif
-                            child.Rotation = rotCache;
-                            nodeRenderingInfos[id] = RenderingTools.RenderInfos!;
+                            List<RenderInfo> renderInfos = new List<RenderInfo>();
+                            foreach(var kv in childProcesser.ChildNodes.GetNodeRenderingInfos(rot, invokeSource))
+                            {
+                                renderInfos.AddRange(kv.Value);
+                            }
+                            nodeRenderingInfos[id] = renderInfos;
                         }
-                        catch (Exception ex)
+                        else
                         {
-                            Log.Error(ex.ToString());
+                            RenderingTools.StartOrEndDrawCatchingBlock = true;
+                            try
+                            {
+                                Rot4 rotCache = child.Rotation;
+                                child.Rotation = new Rot4((rot.AsInt + rotCache.AsInt) & 3);
+    #if V13 || V14
+                                child.DrawAt(Vector3.zero);
+    #else
+                                child.DrawNowAt(Vector3.zero);
+    #endif
+                                child.Rotation = rotCache;
+                                nodeRenderingInfos[id] = RenderingTools.RenderInfos!;
+                            }
+                            catch (Exception ex)
+                            {
+                                Log.Error(ex.ToString());
+                            }
+                            RenderingTools.StartOrEndDrawCatchingBlock = false;
+                            
                         }
-                        RenderingTools.StartOrEndDrawCatchingBlock = false;
                     }
                 }
             }
-            nodeRenderingInfos = Processer.PostGenRenderInfos(rot, invokeSource, nodeRenderingInfos, cachingData) ?? nodeRenderingInfos;
-            List<RenderInfo> final = new List<RenderInfo>();
-            foreach (var infos in nodeRenderingInfos)
-            {
-                if (!infos.Value.NullOrEmpty()) final.AddRange(infos.Value);
-            }
-
-            RenderingTools.RenderToTarget(final, ref cachedRenderTarget, ref target, Processer.TextureFormat, default, Processer.TextureSizeFactor, Processer.ExceedanceFactor, Processer.ExceedanceOffset, PostFX);
-            return;
+            return Processer.PostGenRenderInfos(rot, invokeSource, nodeRenderingInfos, cachingData) ?? nodeRenderingInfos;
+            //Humm, I think i should not use state mechine to handle this...
+            //Time to instead every state check by using various specific method.
+            //But that has too many parts to refactor, FXXK!
         }