private static string GetComponentIcon(UnityComponentDetails details) { string componentIcon; switch (details.ComponentId) { case 53: // Metadata componentIcon = "d_FilterByLabel"; break; case 54: //Position componentIcon = "Transform Icon"; break; case 58: // Interest componentIcon = "d_ViewToolOrbit"; break; default: componentIcon = "d_TextAsset Icon"; break; } if (details.Annotations.TryGetValue("improbable.gdk.editor.ComponentIcon", out var annotations)) { var annotation = annotations[0].TypeValue; var iconNameField = annotation.Fields.First(field => field.Name == "icon_name"); componentIcon = iconNameField.Value.StringValue; } return(componentIcon); }
public CodeWriter Generate(UnityComponentDetails details) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "Unity.Entities", "UnityEngine.UIElements", "UnityEditor.UIElements", "Improbable.Gdk.Debug.WorkerInspector.Codegen" ); cgw.Namespace(details.Namespace, ns => { ns.Type($"public class {details.Name}Renderer : ComponentVisualElement", type => { type.Line($"public override ComponentType ComponentType {{ get; }} = ComponentType.ReadOnly<{details.Name}.Component>();"); type.TextList(details.FieldDetails.Select(typeGenerator.ToFieldDeclaration)); GenerateConstructor(type, details); GenerateUpdateMethod(type, details); }); }); })); }
private void GenerateDebugMethod(TypeBlock typeBlock, UnityComponentDetails details) { typeBlock.Method("protected override void WriteDebugInfo()", mb => { mb.Line($"UnityEngine.Debug.Log(\"{details.Name} generated from '{details.SchemaFilePath}' with Component ID '{details.ComponentId}'\");"); }); }
public static CodeWriter Generate(UnityComponentDetails componentDetails) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "Improbable.Gdk.Core", "Improbable.Gdk.Core.Commands" ); cgw.Namespace(componentDetails.Namespace, ns => { ns.Type($"public partial class {componentDetails.Name}", partial => { foreach (var command in componentDetails.CommandDetails) { Logger.Trace($"Generating {componentDetails.Namespace}.{componentDetails.Name}.{command.PascalCaseName}CommandMetaDataStorage class."); partial.Line($@" private class {command.PascalCaseName}CommandMetaDataStorage : CommandPayloadStorage<{command.FqnRequestType}>, ICommandMetaDataStorage {{ public uint CommandId => {command.CommandIndex}; }} "); } }); }); })); }
public static string Generate(UnityComponentDetails componentDetails, string qualifiedNamespace) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "System", "System.Collections.Generic", "System.Linq", "Improbable.Gdk.Core" ); cgw.Namespace(qualifiedNamespace, ns => { ns.Type($"public partial class {componentDetails.ComponentName}", partial => { partial.Type("internal static class ReferenceTypeProviders", providers => { foreach (var fieldDetails in componentDetails.FieldDetails.Where(fd => !fd.IsBlittable)) { providers.Type(UnityReferenceTypeProviderContent.Generate(fieldDetails, qualifiedNamespace, componentDetails.ComponentName)); } }); }); }); }).Format()); }
public static CodeWriter Generate(UnityComponentDetails componentDetails) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "Improbable.Gdk.Core", "Improbable.Worker.CInterop", "System", "System.Collections.Generic", "System.Diagnostics", "Unity.Entities" ); cgw.Namespace(componentDetails.Namespace, ns => { ns.Type($"public partial class {componentDetails.Name}", partial => { partial.Line($"public const uint ComponentId = {componentDetails.ComponentId};"); partial.Type(GenerateComponentStruct(componentDetails)); partial.Type(GenerateComponentAuthorityStruct(componentDetails)); partial.Type(GenerateSnapshotStruct(componentDetails)); partial.Type(GenerateSerializationClass(componentDetails)); partial.Type(GenerateUpdateStruct(componentDetails)); partial.Type(GenerateInternalDynamicClass(componentDetails)); }); }); })); }
private static TypeBlock GenerateComponentAuthorityStruct(UnityComponentDetails componentDetails) { Logger.Trace( $"Generating {componentDetails.Namespace}.{componentDetails.Name}.ComponentAuthority struct."); return(Scope.Type("public struct HasAuthority : IComponentData", t => { })); }
private static TypeBlock GenerateInternalDynamicClass(UnityComponentDetails componentDetails, string qualifiedNamespace) { Logger.Trace($"Generating {qualifiedNamespace}.{componentDetails.ComponentName}.{componentDetails.ComponentName}Dynamic internal class."); return(Scope.Type($"internal class {componentDetails.ComponentName}Dynamic : IDynamicInvokable", dynamic => { dynamic.Line($"public uint ComponentId => {componentDetails.ComponentName}.ComponentId;"); dynamic.Line(@" internal static Dynamic.VTable<Update, Snapshot> VTable = new Dynamic.VTable<Update, Snapshot> { DeserializeSnapshot = DeserializeSnapshot, SerializeSnapshot = SerializeSnapshot, DeserializeSnapshotRaw = Serialization.DeserializeSnapshot, SerializeSnapshotRaw = Serialization.SerializeSnapshot, ConvertSnapshotToUpdate = SnapshotToUpdate }; private static Snapshot DeserializeSnapshot(ComponentData snapshot) { var schemaDataOpt = snapshot.SchemaData; if (!schemaDataOpt.HasValue) { throw new ArgumentException($""Can not deserialize an empty {nameof(ComponentData)}""); } return Serialization.DeserializeSnapshot(schemaDataOpt.Value.GetFields()); } private static void SerializeSnapshot(Snapshot snapshot, ComponentData data) { var schemaDataOpt = data.SchemaData; if (!schemaDataOpt.HasValue) { throw new ArgumentException($""Can not serialise an empty {nameof(ComponentData)}""); } Serialization.SerializeSnapshot(snapshot, data.SchemaData.Value.GetFields()); } "); dynamic.Method("private static Update SnapshotToUpdate(in Snapshot snapshot)", m => { m.Initializer("var update = new Update", () => { return componentDetails.FieldDetails.Select(fd => $"{fd.PascalCaseName} = snapshot.{fd.PascalCaseName}"); }); m.Return("update"); }); dynamic.Line(@" public void InvokeHandler(Dynamic.IHandler handler) { handler.Accept<Update, Snapshot>(ComponentId, VTable); } "); })); }
public string Generate(UnityComponentDetails details, string package) { qualifiedNamespace = package; this.details = details; return(TransformText()); }
public static string Generate(UnityComponentDetails details, string package) { var qualifiedNamespace = package; var componentDetails = details; var commandDetailsList = details.CommandDetails; var rootNamespace = $"global::{qualifiedNamespace}.{componentDetails.ComponentName}"; var writer = CodeWriter.Populate(cgw => { cgw.UsingDirectives( "System", "Improbable.Gdk.Core", "Improbable.Gdk.Core.Commands" ); cgw.Namespace(qualifiedNamespace, ns => { ns.Type($"public partial class {componentDetails.ComponentName}", partial => { Logger.Trace($"Generating {qualifiedNamespace}.{componentDetails.ComponentName}.ComponentMetaclass class."); partial.Type("public class ComponentMetaclass : IComponentMetaclass", componentMetaclass => { componentMetaclass.Line($@" public uint ComponentId => {componentDetails.ComponentId}; public string Name => ""{componentDetails.ComponentName}""; public Type Data {{ get; }} = typeof({rootNamespace}.Component); public Type Snapshot {{ get; }} = typeof({rootNamespace}.Snapshot); public Type Update {{ get; }} = typeof({rootNamespace}.Update); public Type ReplicationHandler {{ get; }} = typeof({rootNamespace}.ComponentReplicator); public Type Serializer {{ get; }} = typeof({rootNamespace}.ComponentSerializer); public Type DiffDeserializer {{ get; }} = typeof({rootNamespace}.DiffComponentDeserializer); public Type DiffStorage {{ get; }} = typeof({rootNamespace}.DiffComponentStorage); public Type ViewStorage {{ get; }} = typeof({rootNamespace}.{componentDetails.ComponentName}ViewStorage); public Type EcsViewManager {{ get; }} = typeof({rootNamespace}.EcsViewManager); public Type DynamicInvokable {{ get; }} = typeof({rootNamespace}.{componentDetails.ComponentName}Dynamic); "); componentMetaclass.Initializer("public ICommandMetaclass[] Commands { get; } = new ICommandMetaclass[]", () => { return(commandDetailsList.Select(command => $"new {command.CommandName}Metaclass()")); }); }); foreach (var command in commandDetailsList) { partial.Type(GenerateCommandMetaclass(qualifiedNamespace, componentDetails.ComponentName, command)); } }); }); }); return(writer.Format()); }
private static TypeBlock GenerateComponentSerializer(UnityComponentDetails componentDetails) { var eventDetailsList = componentDetails.EventDetails; return(Scope.Type("public class ComponentSerializer : IComponentSerializer", serializer => { serializer.Line($@" private ProfilerMarker serializeMarker = new ProfilerMarker(""{componentDetails.Name}.ComponentSerializer.Serialize""); public uint GetComponentId() {{ return ComponentId; }} "); serializer.Method("public void Serialize(MessagesToSend messages, SerializedMessagesToSend serializedMessages)", m => { m.ProfileScope("serializeMarker", s => { s.Line(@" var storage = messages.GetComponentDiffStorage(ComponentId); var updates = ((IDiffUpdateStorage<Update>) storage).GetUpdates(); for (int i = 0; i < updates.Count; ++i) { ref readonly var update = ref updates[i]; var schemaUpdate = SchemaComponentUpdate.Create(); var componentUpdate = new ComponentUpdate(ComponentId, schemaUpdate); Serialization.SerializeUpdate(update.Update, schemaUpdate); serializedMessages.AddComponentUpdate(componentUpdate, update.EntityId.Id); } "); foreach (var ev in eventDetailsList) { s.CustomScope(() => new[] { $@" var events = ((IDiffEventStorage<{ev.PascalCaseName}.Event>) storage).GetEvents(); for (int i = 0; i < events.Count; ++i) {{ ref readonly var ev = ref events[i]; var schemaUpdate = SchemaComponentUpdate.Create(); var componentUpdate = new ComponentUpdate(ComponentId, schemaUpdate); var obj = schemaUpdate.GetEvents().AddObject({ev.EventIndex}); {ev.FqnPayloadType}.Serialization.Serialize(ev.Event.Payload, obj); serializedMessages.AddComponentUpdate(componentUpdate, ev.EntityId.Id); }} " }); } }); }); })); }
private static TypeBlock GenerateComponentDeserializer(UnityComponentDetails componentDetails) { var componentNamespace = $"global::{componentDetails.Namespace}.{componentDetails.Name}"; var eventDetailsList = componentDetails.EventDetails; Logger.Trace($"Generating {componentDetails.Namespace}.{componentDetails.Name}.DiffComponentDeserializer class."); return(Scope.Type("public class DiffComponentDeserializer : IComponentDiffDeserializer", deserializer => { deserializer.Line(@" public uint GetComponentId() { return ComponentId; } "); deserializer.Method("public void AddUpdateToDiff(ComponentUpdateOp op, ViewDiff diff, uint updateId)", m => { m.If("op.Update.SchemaData.Value.GetFields().GetUniqueFieldIdCount() + op.Update.SchemaData.Value.GetClearedFieldCount() > 0", () => new[] { $"var update = {componentNamespace}.Serialization.DeserializeUpdate(op.Update.SchemaData.Value);", "diff.AddComponentUpdate(update, op.EntityId, op.Update.ComponentId, updateId);" }); if (eventDetailsList.Count > 0) { m.Line("var eventsObject = op.Update.SchemaData.Value.GetEvents();"); foreach (var ev in eventDetailsList) { m.CustomScope(() => new[] { $@" var eventCount = eventsObject.GetObjectCount({ev.EventIndex}); if (eventCount > 0) {{ for (uint i = 0; i < eventCount; i++) {{ var payload = {ev.FqnPayloadType}.Serialization.Deserialize(eventsObject.IndexObject({ev.EventIndex}, i)); var e = new {ev.PascalCaseName}.Event(payload); diff.AddEvent(e, op.EntityId, op.Update.ComponentId, updateId); }} }} " }); } } }); deserializer.Method("public void AddComponentToDiff(AddComponentOp op, ViewDiff diff)", () => new[] { "var data = Serialization.DeserializeUpdate(op.Data.SchemaData.Value);", "diff.AddComponent(data, op.EntityId, op.Data.ComponentId);" }); })); }
private void GenerateUpdateMethod(TypeBlock typeBlock, UnityComponentDetails details) { typeBlock.Method("public override void Update(EntityManager manager, Entity entity)", mb => { mb.Line($"AuthoritativeToggle.value = manager.HasComponent<{details.Name}.HasAuthority>(entity);"); mb.Line($"var component = manager.GetComponentData<{details.Name}.Component>(entity);"); mb.TextList(details.FieldDetails.Select(fd => typeGenerator.ToUiFieldUpdate(fd, "component"))); }); }
public static CodeWriter Generate(UnityComponentDetails componentDetails) { var commandDetailsList = componentDetails.CommandDetails; var rootNamespace = $"global::{componentDetails.Namespace}.{componentDetails.Name}"; return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "System", "Improbable.Gdk.Core", "Improbable.Gdk.Core.Commands" ); cgw.Namespace(componentDetails.Namespace, ns => { ns.Type($"public partial class {componentDetails.Name}", partial => { Logger.Trace($"Generating {componentDetails.Namespace}.{componentDetails.Name}.ComponentMetaclass class."); partial.Type("public class ComponentMetaclass : IComponentMetaclass", componentMetaclass => { componentMetaclass.Line($@" public uint ComponentId => {componentDetails.ComponentId}; public string Name => ""{componentDetails.Name}""; public Type Data {{ get; }} = typeof({rootNamespace}.Component); public Type Authority {{ get; }} = typeof({rootNamespace}.HasAuthority); public Type Snapshot {{ get; }} = typeof({rootNamespace}.Snapshot); public Type Update {{ get; }} = typeof({rootNamespace}.Update); public Type ReplicationSystem {{ get; }} = typeof({rootNamespace}.ReplicationSystem); public Type Serializer {{ get; }} = typeof({rootNamespace}.ComponentSerializer); public Type DiffDeserializer {{ get; }} = typeof({rootNamespace}.DiffComponentDeserializer); public Type DiffStorage {{ get; }} = typeof({rootNamespace}.DiffComponentStorage); public Type EcsViewManager {{ get; }} = typeof({rootNamespace}.EcsViewManager); public Type DynamicInvokable {{ get; }} = typeof({rootNamespace}.{componentDetails.Name}Dynamic); "); componentMetaclass.Initializer("public ICommandMetaclass[] Commands { get; } = new ICommandMetaclass[]", () => { return commandDetailsList.Select(command => $"new {command.PascalCaseName}Metaclass()"); }); }); foreach (var command in commandDetailsList) { partial.Type(GenerateCommandMetaclass(componentDetails.Namespace, componentDetails.Name, command)); } }); }); })); }
private static TypeBlock GenerateUpdateStruct(UnityComponentDetails componentDetails) { Logger.Trace($"Generating {componentDetails.Namespace}.{componentDetails.Name}.Update struct."); return(Scope.Type("public struct Update : ISpatialComponentUpdate", update => { update.Line(componentDetails.FieldDetails.Select(fd => $"public Option<{fd.Type}> {fd.PascalCaseName};").ToList()); })); }
private static TypeBlock GenerateComponentWriter(UnityComponentDetails componentDetails, string qualifiedNamespace) { Logger.Trace($"Generating {qualifiedNamespace}.{componentDetails.ComponentName}Writer class."); return(Scope.Type($"public class {componentDetails.ComponentName}Writer : {componentDetails.ComponentName}Reader", writer => { writer.Line($@" internal {componentDetails.ComponentName}Writer(World world, Entity entity, EntityId entityId) : base(world, entity, entityId) {{ }} "); writer.Method($"public void SendUpdate({componentDetails.ComponentName}.Update update)", m => { m.Line($"var component = EntityManager.GetComponentData<{componentDetails.ComponentName}.Component>(Entity);"); foreach (var fieldDetails in componentDetails.FieldDetails) { m.Line($@" if (update.{fieldDetails.PascalCaseName}.HasValue) {{ component.{fieldDetails.PascalCaseName} = update.{fieldDetails.PascalCaseName}.Value; }} "); } m.Line($"EntityManager.SetComponentData(Entity, component);"); }); foreach (var eventDetails in componentDetails.EventDetails) { var eventType = $"{componentDetails.ComponentName}.{eventDetails.EventName}.Event"; writer.Line($@" public void Send{eventDetails.EventName}Event({eventDetails.FqnPayloadType} {eventDetails.CamelCaseEventName}) {{ var eventToSend = new {eventType}({eventDetails.CamelCaseEventName}); ComponentUpdateSystem.SendEvent(eventToSend, EntityId); }} "); } writer.Line($@" public void AcknowledgeAuthorityLoss() {{ ComponentUpdateSystem.AcknowledgeAuthorityLoss(EntityId, {componentDetails.ComponentName}.ComponentId); }} "); })); }
private static TypeBlock GenerateComponentAuthorityStruct(UnityComponentDetails componentDetails, string qualifiedNamespace) { Logger.Trace( $"Generating {qualifiedNamespace}.{componentDetails.ComponentName}.ComponentAuthority struct."); return(Scope.Type("public struct ComponentAuthority : ISharedComponentData, IEquatable<ComponentAuthority>", t => { t.Line(@" public bool HasAuthority; public ComponentAuthority(bool hasAuthority) { HasAuthority = hasAuthority; } // todo think about whether any of this is necessary // Unity does a bitwise equality check so this is just for users reading the struct public static readonly ComponentAuthority NotAuthoritative = new ComponentAuthority(false); public static readonly ComponentAuthority Authoritative = new ComponentAuthority(true); public bool Equals(ComponentAuthority other) { return this == other; } public override bool Equals(object obj) { return obj is ComponentAuthority auth && this == auth; } public override int GetHashCode() { return HasAuthority.GetHashCode(); } public static bool operator ==(ComponentAuthority a, ComponentAuthority b) { return a.HasAuthority == b.HasAuthority; } public static bool operator !=(ComponentAuthority a, ComponentAuthority b) { return !(a == b); } "); })); }
private void GenerateConstructor(TypeBlock typeBlock, UnityComponentDetails details) { typeBlock.Method($"public {details.Name}Renderer() : base()", mb => { mb.Line($"ComponentFoldout.text = \"{details.Name}\";"); mb.Line($"AuthoritativeToggle.SetEnabled(false);"); foreach (var field in details.FieldDetails) { mb.TextList(typeGenerator.ToFieldInitialisation(field, "ComponentFoldout")); } mb.Line($"InjectComponentIcon(\"{GetComponentIcon(details)}\");"); }); }
public static string Generate(UnityComponentDetails details, string package) { var qualifiedNamespace = package; var componentName = details.ComponentName; return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "System.Collections.Generic", "Improbable.Gdk.Core", "Improbable.Worker", "Unity.Entities" ); cgw.Namespace(qualifiedNamespace, ns => { ns.Type($"public partial class {componentName}", partial => { foreach (var eventDetail in details.EventDetails) { var eventName = eventDetail.EventName; var payloadType = eventDetail.FqnPayloadType; Logger.Trace($"Generating {qualifiedNamespace}.{componentName}.{eventName} class."); partial.Line($@" public static class {eventName} {{ public readonly struct Event : IEvent {{ public readonly {payloadType} Payload; public Event({payloadType} payload) {{ Payload = payload; }} }} }} "); } }); }); }).Format()); }
public static CodeWriter Generate(UnityComponentDetails componentDetails) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "Improbable.Gdk.Core", "Improbable.Worker.CInterop" ); cgw.Namespace(componentDetails.Namespace, ns => { ns.Type($"public partial class {componentDetails.Name}", partial => { partial.Type(GenerateComponentDeserializer(componentDetails)); partial.Type(GenerateComponentSerializer(componentDetails)); }); }); })); }
private static TypeBlock GenerateComponentWriterSubscriptionManager(UnityComponentDetails componentDetails) { Logger.Trace($"Generating {componentDetails.Namespace}.{componentDetails.Name}WriterSubscriptionManager class."); var componentWriterType = $"{componentDetails.Name}Writer"; return(Scope.AnnotatedType("AutoRegisterSubscriptionManager", $"public class {componentDetails.Name}WriterSubscriptionManager : WriterSubscriptionManager<{componentDetails.Name}.Component, {componentWriterType}>", wsm => { wsm.Line($@" public {componentDetails.Name}WriterSubscriptionManager(World world) : base(world) {{ }} protected override {componentWriterType} CreateWriter(Entity entity, EntityId entityId) {{ return new {componentWriterType}(World, entity, entityId); }} "); })); }
public static string Generate(UnityComponentDetails componentDetails, string qualifiedNamespace) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "Improbable.Gdk.Core", "Improbable.Gdk.Core.Commands" ); cgw.Namespace(qualifiedNamespace, ns => { ns.Type($"public partial class {componentDetails.ComponentName}", partial => { foreach (var command in componentDetails.CommandDetails) { partial.Text(GenerateCommandStorage(command, qualifiedNamespace, componentDetails.ComponentName)); partial.Text(GenerateCommandsToSendStorage(command, qualifiedNamespace, componentDetails.ComponentName)); } }); }); }).Format()); }
private static TypeBlock GenerateCommandReceiverSubscriptionManager(UnityComponentDetails componentDetails, string qualifiedNamespace) { Logger.Trace($"Generating {qualifiedNamespace}.{componentDetails.ComponentName}CommandReceiverSubscriptionManager class."); var commandReceiverType = $"{componentDetails.ComponentName}CommandReceiver"; return(Scope.AnnotatedType("AutoRegisterSubscriptionManager", $"public class {componentDetails.ComponentName}CommandReceiverSubscriptionManager : CommandReceiverSubscriptionManagerBase<{commandReceiverType}>", t => { t.Line($@" public {componentDetails.ComponentName}CommandReceiverSubscriptionManager(World world) : base(world, {componentDetails.ComponentName}.ComponentId) {{ }} protected override {commandReceiverType} CreateReceiver(World world, Entity entity, EntityId entityId) {{ return new {commandReceiverType}(world, entity, entityId); }} "); })); }
private static TypeBlock GenerateSnapshotStruct(UnityComponentDetails componentDetails, string qualifiedNamespace) { Logger.Trace($"Generating {qualifiedNamespace}.{componentDetails.ComponentName}.Snapshot struct."); var fieldDetailsList = componentDetails.FieldDetails; return(Scope.AnnotatedType("global::System.Serializable", "public struct Snapshot : ISpatialComponentSnapshot", snapshot => { snapshot.Line($"public uint ComponentId => {componentDetails.ComponentId};"); snapshot.Line(fieldDetailsList.Select(fd => $"public {fd.Type} {fd.PascalCaseName};").ToList()); if (fieldDetailsList.Count > 0) { snapshot.Method($"public Snapshot({GetConstructorArgs(fieldDetailsList)})", () => { return fieldDetailsList.Select(fd => $"{fd.PascalCaseName} = {fd.CamelCaseName};"); }); } })); }
public static CodeWriter Generate(UnityComponentDetails details) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "System", "System.Collections.Generic", "Improbable.Gdk.Core", "Improbable.Gdk.Subscriptions", "Unity.Entities", "Entity = Unity.Entities.Entity" ); cgw.Namespace(details.Namespace, ns => { ns.Type(GenerateComponentReaderSubscriptionManager(details)); ns.Type(GenerateComponentWriterSubscriptionManager(details)); ns.Type(GenerateComponentReader(details)); ns.Type(GenerateComponentWriter(details)); }); })); }
private static TypeBlock GenerateCommandSenderSubscriptionManager(UnityComponentDetails componentDetails) { Logger.Trace($"Generating {componentDetails.Namespace}.{componentDetails.Name}CommandSenderSubscriptionManager class."); var commandSenderType = $"{componentDetails.Name}CommandSender"; return(Scope.AnnotatedType("AutoRegisterSubscriptionManager", $"public class {componentDetails.Name}CommandSenderSubscriptionManager : CommandSenderSubscriptionManagerBase<{commandSenderType}>", t => { t.Line($@" public {componentDetails.Name}CommandSenderSubscriptionManager(World world) : base(world) {{ }} protected override {commandSenderType} CreateSender(Entity entity, World world) {{ return new {commandSenderType}(entity, world); }} "); })); }
public static CodeWriter Generate(UnityComponentDetails componentDetails) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "Improbable.Gdk.Core", "Improbable.Gdk.Core.Commands", "Improbable.Worker.CInterop" ); cgw.Namespace(componentDetails.Namespace, ns => { ns.Type($"public partial class {componentDetails.Name}", partial => { foreach (var command in componentDetails.CommandDetails) { partial.Text(GenerateDiffCommandDeserializer(command, componentDetails.Namespace, componentDetails.Name)); partial.Text(GenerateCommandSerializer(command, componentDetails.Namespace, componentDetails.Name)); } }); }); })); }
public static string Generate(UnityComponentDetails details, string package) { return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "System", "System.Collections.Generic", "Improbable.Worker.CInterop", "Improbable.Gdk.Core", "Improbable.Gdk.Subscriptions", "Unity.Entities", "Entity = Unity.Entities.Entity" ); cgw.Namespace(package, ns => { ns.Type(GenerateComponentReaderSubscriptionManager(details, package)); ns.Type(GenerateComponentWriterSubscriptionManager(details, package)); ns.Type(GenerateComponentReader(details, package)); ns.Type(GenerateComponentWriter(details, package)); }); }).Format()); }
public static string Generate(UnityComponentDetails componentDetails, string package) { var qualifiedNamespace = package; return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "Improbable.Gdk.Core", "Improbable.Worker.CInterop" ); cgw.Namespace(qualifiedNamespace, ns => { ns.Type($"public partial class {componentDetails.ComponentName}", partial => { foreach (var command in componentDetails.CommandDetails) { partial.Text(GenerateDiffCommandDeserializer(command, qualifiedNamespace, componentDetails.ComponentName)); partial.Text(GenerateCommandSerializer(command, qualifiedNamespace, componentDetails.ComponentName)); } }); }); }).Format()); }
public static CodeWriter Generate(UnityComponentDetails details) { var fullyQualifiedNamespace = $"global::{details.Namespace}.{details.Name}"; return(CodeWriter.Populate(cgw => { cgw.UsingDirectives( "System", "System.Collections.Generic", "Unity.Entities", "Improbable.Gdk.Core", "Improbable.Gdk.Subscriptions", "Entity = Unity.Entities.Entity" ); cgw.Namespace(details.Namespace, ns => { ns.Type(GenerateCommandSenderSubscriptionManager(details)); ns.Type(GenerateCommandReceiverSubscriptionManager(details)); ns.Type(GenerateCommandSender(details, fullyQualifiedNamespace)); ns.Type(GenerateCommandReceiver(details, fullyQualifiedNamespace)); }); })); }