chore: initialize standalone UPM package

2026-08-26 02:50:38 +08:00
commit 05bfe9c430
43 changed files with 1417 additions and 0 deletions
@@ -0,0 +1,184 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+using Mono.Cecil.Pdb;
+using ShrinkEventBus.CodeGen;
+using Unity.CompilationPipeline.Common.Diagnostics;
+using Unity.CompilationPipeline.Common.ILPostProcessing;
+
+namespace ShrinkNetwork.Integration.CodeGen
+{
+    public sealed class NetworkEventILPostProcessor : ILPostProcessor
+    {
+        private const string IntegrationAssembly = "ShrinkNetwork.Integration.EventBus";
+
+        public override ILPostProcessor GetInstance() => this;
+
+        public override bool WillProcess(ICompiledAssembly compiledAssembly) =>
+            compiledAssembly.References.Any(reference =>
+                string.Equals(Path.GetFileNameWithoutExtension(reference), IntegrationAssembly,
+                    StringComparison.Ordinal));
+
+        public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
+        {
+            var diagnostics = new List<DiagnosticMessage>();
+            if (!WillProcess(compiledAssembly))
+                return new ILPostProcessResult(compiledAssembly.InMemoryAssembly, diagnostics);
+
+            var assembly = ReadAssembly(compiledAssembly);
+            try
+            {
+                InjectRegistrations(assembly.MainModule);
+            }
+            catch (Exception exception)
+            {
+                diagnostics.Add(new DiagnosticMessage
+                {
+                    DiagnosticType = DiagnosticType.Error,
+                    MessageData = $"[ShrinkNetwork.EventBus.CodeGen] {exception.Message}"
+                });
+            }
+            return WriteAssembly(assembly, diagnostics);
+        }
+
+        private static void InjectRegistrations(ModuleDefinition module)
+        {
+            var networkEventAttribute = ResolveType(module,
+                "ShrinkNetwork.Integration.ShrinkNetworkEventAttribute", IntegrationAssembly);
+            var messageAttribute = ResolveType(module,
+                "ShrinkNetwork.ShrinkNetworkMessageAttribute", "ShrinkNetwork.Runtime");
+            var registryType = ResolveType(module,
+                "ShrinkNetwork.Integration.ShrinkNetworkEventRegistry", IntegrationAssembly);
+            if (networkEventAttribute == null || messageAttribute == null || registryType == null)
+                return;
+
+            var registrations = GetAllTypes(module.Types)
+                .Where(type => !type.IsAbstract && HasAttribute(type, networkEventAttribute))
+                .Select(type => new
+                {
+                    Type = type,
+                    Message = type.CustomAttributes.FirstOrDefault(attribute =>
+                        attribute.AttributeType.FullName == messageAttribute.FullName)
+                })
+                .Where(item => item.Message != null)
+                .ToArray();
+            if (registrations.Length == 0)
+                return;
+
+            var registerDefinition = registryType.Resolve()?.Methods.Single(method =>
+                method.Name == "Register" && method.HasGenericParameters)
+                ?? throw new InvalidOperationException("ShrinkNetworkEventRegistry.Register<T> was not found.");
+            var registerOpen = module.ImportReference(registerDefinition);
+
+            var bootstrap = new TypeDefinition("ShrinkNetwork.Integration.Generated",
+                "ShrinkGeneratedNetworkEventBindings",
+                TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.NotPublic,
+                module.TypeSystem.Object);
+            module.Types.Add(bootstrap);
+            var initialize = new MethodDefinition("Register",
+                MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig,
+                module.TypeSystem.Void);
+            bootstrap.Methods.Add(initialize);
+            var il = initialize.Body.GetILProcessor();
+
+            foreach (var item in registrations)
+            {
+                var attribute = item.Message!;
+                if (attribute.ConstructorArguments.Count == 0)
+                    throw new InvalidOperationException(
+                        $"[ShrinkNetworkMessage] on {item.Type.FullName} has no opcode.");
+
+                var opcode = Convert.ToInt32(attribute.ConstructorArguments[0].Value);
+                var route = attribute.ConstructorArguments.Count > 1
+                    ? attribute.ConstructorArguments[1].Value as string
+                    : null;
+                var registerClosed = new GenericInstanceMethod(registerOpen);
+                registerClosed.GenericArguments.Add(module.ImportReference(item.Type));
+                il.Emit(OpCodes.Ldc_I4, opcode);
+                if (route == null)
+                    il.Emit(OpCodes.Ldnull);
+                else
+                    il.Emit(OpCodes.Ldstr, route);
+                il.Emit(OpCodes.Call, registerClosed);
+            }
+            il.Emit(OpCodes.Ret);
+            InjectModuleInitializer(module, initialize);
+        }
+
+        private static void InjectModuleInitializer(ModuleDefinition module, MethodReference register)
+        {
+            var moduleType = module.Types.First(type => type.Name == "<Module>");
+            var initializer = moduleType.Methods.FirstOrDefault(method => method.Name == ".cctor");
+            if (initializer == null)
+            {
+                initializer = new MethodDefinition(".cctor",
+                    MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig |
+                    MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
+                    module.TypeSystem.Void);
+                initializer.Body.GetILProcessor().Emit(OpCodes.Ret);
+                moduleType.Methods.Add(initializer);
+            }
+            var il = initializer.Body.GetILProcessor();
+            il.InsertBefore(initializer.Body.Instructions[0], il.Create(OpCodes.Call, register));
+        }
+
+        private static bool HasAttribute(ICustomAttributeProvider provider, TypeReference attributeType) =>
+            provider.CustomAttributes.Any(attribute =>
+                attribute.AttributeType.FullName == attributeType.FullName);
+
+        private static IEnumerable<TypeDefinition> GetAllTypes(IEnumerable<TypeDefinition> roots)
+        {
+            foreach (var type in roots)
+            {
+                yield return type;
+                foreach (var nested in GetAllTypes(type.NestedTypes))
+                    yield return nested;
+            }
+        }
+
+        private static TypeReference? ResolveType(ModuleDefinition module, string fullName,
+            string assemblyName)
+        {
+            var reference = module.AssemblyReferences.FirstOrDefault(item => item.Name == assemblyName);
+            var definition = reference == null ? null : module.AssemblyResolver.Resolve(reference);
+            var type = definition?.MainModule.GetType(fullName);
+            return type == null ? null : module.ImportReference(type);
+        }
+
+        private static AssemblyDefinition ReadAssembly(ICompiledAssembly compiledAssembly)
+        {
+            var resolver = new PostProcessorAssemblyResolver(compiledAssembly);
+            var parameters = new ReaderParameters
+            {
+                SymbolStream = new MemoryStream(compiledAssembly.InMemoryAssembly.PdbData.ToArray()),
+                SymbolReaderProvider = new PdbReaderProvider(),
+                AssemblyResolver = resolver,
+                ReflectionImporterProvider = new PostProcessorReflectionImporterProvider(),
+                ReadingMode = ReadingMode.Immediate
+            };
+            var assembly = AssemblyDefinition.ReadAssembly(
+                new MemoryStream(compiledAssembly.InMemoryAssembly.PeData.ToArray()), parameters);
+            resolver.AddAssemblyDefinitionBeingOperatedOn(assembly);
+            return assembly;
+        }
+
+        private static ILPostProcessResult WriteAssembly(AssemblyDefinition assembly,
+            List<DiagnosticMessage> diagnostics)
+        {
+            var pe = new MemoryStream();
+            var pdb = new MemoryStream();
+            assembly.Write(pe, new WriterParameters
+            {
+                SymbolWriterProvider = new PdbWriterProvider(),
+                SymbolStream = pdb,
+                WriteSymbols = true
+            });
+            return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), diagnostics);
+        }
+    }
+}