Merge pull request #52 from InitialPrefabs/develop

Develop - Disabling (0.2.0)

Author: psuong

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+## 0.2.0
+### Added
+* Added `ChildrenActiveMetadata` component to store the state of the visibility of the entity
+* Added the `EnableRenderingTag` to mark entities as newly rendering
+* Added the `ToggleVisibilitySystem` to manage the state of the entities' visibility
+* Added a `ReactiveSubgroupToggleSystem` to clean up entities when they are disabled/enabled.
+
+### Changed
+* Changed the `UpdateLocalMeshDataSystem` to react to the state of the entity. See the wiki page about 
+[closing](Wiki/Close.md) for more details.
+* Changed the `CanvasConversionSystem` to populate and add the `ChildrenActiveMetadataSystem`.
+* Changed the `BuildImageVertexDataSystem` and `BuildTextVertexDataSystem` to include disabled entities.
+* Changed the `RenderCommand` to be a managed `IComponentData` instead.
+
 ## 0.1.3
 ### Fixed
 * Fixed issue regarding render texture cameras

Controls/Authoring/ButtonTypeAuthoring.cs

@@ -2,6 +2,7 @@
 using UnityEngine;
 
 namespace UGUIDots.Controls.Authoring {
+
     public class ButtonTypeAuthoring : MonoBehaviour, IConvertGameObjectToEntity {
 
         public ClickType Type = ClickType.ReleaseUp;

Controls/Authoring/CloseButtonAuthoring.cs

@@ -0,0 +1,54 @@
+using Unity.Entities;
+using UnityEngine;
+
+namespace UGUIDots.Controls.Authoring {
+
+    public enum ButtonVisibilityType {
+        Close,
+        Show,
+        Toggle
+    }
+
+    public class CloseButtonAuthoring : MonoBehaviour, IConvertGameObjectToEntity {
+
+        public ButtonVisibilityType Type = ButtonVisibilityType.Toggle;
+        public GameObject[] Targets;
+
+        public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem) {
+#if UNITY_EDITOR
+            if (Targets.Length == 0) {
+                throw new System.InvalidOperationException("Cannot send a message to a GameObject that is null!");
+            }
+#endif
+
+            // Create the message which will try to close something
+            var msg = dstManager.CreateEntity();
+
+            switch (Type) {
+                case ButtonVisibilityType.Toggle:
+                    dstManager.AddComponentData(msg, new ToggleButtonType { });
+                    break;
+                case ButtonVisibilityType.Show:
+                    dstManager.AddComponentData(msg, new ShowButtonType { });
+                    break;
+                case ButtonVisibilityType.Close:
+                    dstManager.AddComponentData(msg, new CloseButtonType { });
+                    break;
+                default:
+                    break;
+            }
+
+            var buffer = dstManager.AddBuffer<CloseTarget>(msg); 
+
+            foreach (var target in Targets) {
+                buffer.Add(new CloseTarget { Value = conversionSystem.GetPrimaryEntity(target) });
+            }
+
+            dstManager.AddComponentData(entity, new ButtonMessageFramePayload { Value = msg });
+
+#if UNITY_EDITOR
+            dstManager.SetName(msg, "Close Target Msg");
+#endif
+        }
+    }
+}

Core/Systems/ReactiveDisableHierarchySystem.cs.meta renamed to Controls/Authoring/CloseButtonAuthoring.cs.meta

@@ -5,6 +5,13 @@
 
 namespace UGUIDots.Controls {
 
+    /// <summary>
+    /// The entity which is targetted to be disabled.
+    /// </summary>
+    public struct CloseTarget : IBufferElementData {
+        public Entity Value;
+    }
+
     /// <summary>
     /// The type of the button behaviour.
     /// </summary>

Controls/Components/ButtonControlComponents.cs

@@ -0,0 +1,151 @@
+using UGUIDots.Render;
+using UGUIDots.Transforms;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using Unity.Entities;
+using Unity.Transforms;
+
+namespace UGUIDots.Controls.Messaging.Systems {
+
+    [UpdateInGroup(typeof(MessagingUpdateGroup))]
+    public class ToggleVisibilitySystem : SystemBase {
+
+        [BurstCompile]
+        private struct ToggleJob { 
+
+            public EntityCommandBuffer CmdBuffer;
+
+            [ReadOnly]
+            public ComponentDataFromEntity<Disabled> Disabled;
+
+            [ReadOnly]
+            public ComponentDataFromEntity<Parent> Parents;
+
+            [ReadOnly]
+            public BufferFromEntity<Child> Children;
+
+            [ReadOnly]
+            public ComponentDataFromEntity<ShowButtonType> ShowButtons;
+
+            [ReadOnly]
+            public ComponentDataFromEntity<ToggleButtonType> ToggleButtons;
+
+            [ReadOnly]
+            public ComponentDataFromEntity<CloseButtonType> CloseButtons;
+
+            [ReadOnly]
+            public BufferFromEntity<LocalVertexData> LocalVertices;
+
+            public ComponentDataFromEntity<ChildrenActiveMetadata> Metadata;
+
+            public void Execute(Entity msgEntity, DynamicBuffer<CloseTarget> b0) {
+                var buffer = b0.AsNativeArray();
+
+                for (int i = 0; i < buffer.Length; i++) {
+                    var targetEntity = buffer[i].Value;
+
+                    // Check the metadata of the entity and update its state
+                    var root         = HierarchyUtils.GetRoot(targetEntity, Parents);
+                    var activeStates = Metadata[root];
+
+                    if (activeStates.Value.TryGetValue(targetEntity, out bool isActive)) {
+                        isActive = !isActive;
+                        activeStates.Value[targetEntity] = isActive;
+                    }
+
+                    if (isActive && Disabled.Exists(targetEntity) && 
+                        (ShowButtons.Exists(msgEntity) || ToggleButtons.Exists(msgEntity))) {
+
+                        CmdBuffer.RemoveComponent<Disabled>(targetEntity);
+                        CmdBuffer.AddComponent<EnableRenderingTag>(targetEntity);
+
+                        if (LocalVertices.Exists(targetEntity)) {
+                            CmdBuffer.AddComponent<UpdateVertexColorTag>(targetEntity);
+                        }
+                        RecurseChildrenAndEnable(targetEntity, ref activeStates.Value);
+                    }
+
+                    if (!isActive && (CloseButtons.Exists(msgEntity) || ToggleButtons.Exists(msgEntity))) {
+                        CmdBuffer.AddComponent<Disabled>(targetEntity);
+
+                        if (LocalVertices.Exists(targetEntity)) {
+                            CmdBuffer.AddComponent<UpdateVertexColorTag>(targetEntity);
+                        }
+
+                        RecurseChildrenAndDisabled(targetEntity);
+                    }
+                }
+            }
+
+
+            private void RecurseChildrenAndDisabled(Entity entity) {
+                if (!Children.Exists(entity)) {
+                    return;
+                }
+
+                var children = Children[entity].AsNativeArray();
+
+                for (int i = 0; i < children.Length; i++) {
+                    var child = children[i].Value;
+
+                    CmdBuffer.AddComponent<Disabled>(child);
+                    CmdBuffer.AddComponent<UpdateVertexColorTag>(child);
+                    RecurseChildrenAndDisabled(child);
+                }
+            }
+
+            private void RecurseChildrenAndEnable(Entity entity, ref UnsafeHashMap<Entity, bool> metadata) {
+                if (!Children.Exists(entity)) {
+                    return;
+                }
+
+                var children = Children[entity].AsNativeArray();
+
+                for (int i = 0; i < children.Length; i++) {
+                    var child = children[i].Value;
+
+                    CmdBuffer.AddComponent<EnableRenderingTag>(child);
+                    CmdBuffer.AddComponent<UpdateVertexColorTag>(child);
+
+                    metadata.TryGetValue(child, out bool isActive);
+
+                    if (isActive) {
+                        CmdBuffer.RemoveComponent<Disabled>(child);
+                    }
+
+                    RecurseChildrenAndEnable(child, ref metadata);
+                }
+            }
+        }
+
+        private EntityCommandBufferSystem cmdBufferSystem;
+
+        protected override void OnCreate() {
+            cmdBufferSystem = World.GetOrCreateSystem<BeginPresentationEntityCommandBufferSystem>();
+        }
+
+        protected override void OnUpdate() {
+            var job           = new ToggleJob {
+                CmdBuffer     = cmdBufferSystem.CreateCommandBuffer(),
+                Parents       = GetComponentDataFromEntity<Parent>(true),
+                Metadata      = GetComponentDataFromEntity<ChildrenActiveMetadata>(false),
+                Children      = GetBufferFromEntity<Child>(true),
+                Disabled      = GetComponentDataFromEntity<Disabled>(true),
+                ShowButtons   = GetComponentDataFromEntity<ShowButtonType>(true),
+                CloseButtons  = GetComponentDataFromEntity<CloseButtonType>(true),
+                ToggleButtons = GetComponentDataFromEntity<ToggleButtonType>(true),
+                LocalVertices = GetBufferFromEntity<LocalVertexData>(true)
+            };
+
+            Dependency = Entities.WithAll<ButtonMessageRequest>().
+                WithAny<ShowButtonType, CloseButtonType, ToggleButtonType>().
+                ForEach((Entity entity, DynamicBuffer<CloseTarget> b0) => {
+
+                job.Execute(entity, b0);
+            }).Schedule(Dependency);
+
+            cmdBufferSystem.AddJobHandleForProducer(Dependency);
+        }
+    }
+}

Controls/Systems/Messaging/ToggleVisibilitySystem.cs

@@ -19,7 +19,7 @@ protected unsafe override void OnUpdate() {
             }).WithNativeDisableUnsafePtrRestriction(touches).WithNativeDisableUnsafePtrRestriction(size).Run();
 
             Entities.WithNativeDisableUnsafePtrRestriction(touches).WithNativeDisableUnsafePtrRestriction(size).
-                WithNone<ButtonDisabledTag>().
+                WithNone<NonInteractableButtontag>().
                 ForEach((ref ClickState c0, ref ButtonVisual c1, in Dimensions c2, in LocalToWorld c3, in ButtonClickType c4) => {
                 var aabb = new AABB {
                     Center  = c3.Position,

Controls/Systems/Messaging/ToggleVisibilitySystem.cs.meta

@@ -31,7 +31,7 @@ protected override void OnUpdate() {
                 Pressed = new bool2(clickDown, clickUp)
             };
 
-            Dependency = Entities.WithNone<ButtonDisabledTag>().ForEach((ref ClickState c0, ref ButtonVisual c1, 
+            Entities.WithNone<NonInteractableButtontag>().ForEach((ref ClickState c0, ref ButtonVisual c1, 
                 in Dimensions c2, in LocalToWorld c3, in ButtonClickType c4) => {
 
                 var aabb = new AABB {
@@ -58,7 +58,7 @@ protected override void OnUpdate() {
                 } else {
                     c1.Value = ButtonVisualState.None;
                 }
-            }).ScheduleParallel(Dependency);
+            }).Run();
         }
     }
 }

Controls/Systems/Mobile/MobileMouseCollisionSystem.cs

@@ -1,4 +1,5 @@
-using Unity.Entities;
+using System;
+using Unity.Entities;
 using UnityEngine;
 
 namespace UGUIDots.Render.Authoring {
@@ -8,9 +9,11 @@ public class RenderCommandAuthoring : MonoBehaviour, IConvertGameObjectToEntity
         public OrthographicRenderFeature RenderFeature;
 
         public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem) {
-            dstManager.AddSharedComponentData(entity, new RenderCommand {
-                RenderFeature = RenderFeature
-            });
+            if (ReferenceEquals(RenderFeature, null)) {
+                throw new ArgumentException("The RenderFeature cannot be null!");
+            }
+
+            dstManager.AddComponentData(entity, new RenderCommand { RenderFeature = RenderFeature });
         }
     }
-}
+}