public GameObject Build(IRootElementBuilder previousBuilder, Transform parent)
        {
            var previousGameObjectElementBuilder = previousBuilder as GameObjectElementBuilder;

            RootGameObject = previousGameObjectElementBuilder?.RootGameObject
                ? previousGameObjectElementBuilder?.RootGameObject
                : new GameObject();

            RootGameObject.transform.SetParent(parent);

            for (var i = 0; i < components.Count; i++)
            {
                components[i].Build(RootGameObject, previousGameObjectElementBuilder?.components[i]);
            }

            foreach (var key in setters.Keys)
            {
                ReflectionUtils.SetProperty(RootGameObject, setters[key], valuesForSetters[key]);
            }

            for (var i = 0; i < childBuilders.Count; i++)
            {
                var childObjects = childBuilders[i].Build(
                    previousGameObjectElementBuilder?.childBuilders[i],
                    RootGameObject.transform);
            }

            return(RootGameObject);
        }
        public GameObject Build(IRootElementBuilder previousBuilder, IObjectPool pool, Transform parent = null)
        {
            var previousGameObjectElementBuilder = previousBuilder as GameObjectElementBuilder;

            RootGameObject = previousGameObjectElementBuilder?.RootGameObject != null
                ? previousGameObjectElementBuilder?.RootGameObject
                : new GameObject(Name);

            RootGameObject.transform.SetParent(parent ? parent : pool.Root);

            for (var i = 0; i < components.Count; i++)
            {
                components[i].Build(RootGameObject, previousGameObjectElementBuilder?.components[i]);
            }

            foreach (var key in setters.Keys)
            {
                if (previousGameObjectElementBuilder?.valuesForSetters.ContainsKey(key) != true ||
                    !previousGameObjectElementBuilder.valuesForSetters[key].Equals(valuesForSetters[key]))
                {
                    ReflectionUtils.SetProperty(RootGameObject, setters[key], valuesForSetters[key]);
                }
            }

            return(RootGameObject);
        }
Ejemplo n.º 3
0
        private void Start()
        {
            var i = ComponentPool.Instance;

            rootElement = Element.Create(rootComponent.Create(), new PropCollection(new Dictionary <string, object>()));

            var t = new Thread(() =>
            {
                while (true)
                {
                    if (changed)
                    {
                        continue;
                    }

                    var newBuilder = rootElement.Render();

                    if (newBuilder == null)
                    {
                        continue;
                    }

                    lock (_locker)
                    {
                        previousBuilder = builder;
                        builder         = newBuilder;
                        changed         = true;
                    }
                }
            });

            t.Start();
        }
        public GameObject Build(IRootElementBuilder previousBuilder, Transform parent)
        {
            var previousPassThroughBuilder = (previousBuilder as PassThroughElementBuilder);
            var previousChildBuilder       = previousPassThroughBuilder?.childBuilder;

            return(childBuilder.Build(previousChildBuilder, parent));
        }
 public void AddChildBuilder(IRootElementBuilder builder)
 {
     childBuilders.Add(builder);
 }
 public PassThroughElementBuilder(IRootElementBuilder builder)
 {
     childBuilder = builder;
 }