public void GeneratedAuthoringComponent_WithMultipleReferences_ConvertsOnlyPrefab()
        {
            var go = CreateGameObject();

            var authoringType = GetAuthoringComponentType <CodeGenManagedTestComponent>();
            var c             = go.AddComponent(authoringType);

            authoringType.GetField(nameof(CodeGenManagedTestComponent.Entities)).SetValue(c, new[]
            {
                LoadPrefab("Prefab"),
                null,
                CreateGameObject()
            });

            LogAssert.Expect(LogType.Warning, new Regex(@"GameObject that was not included in the conversion"));
            Entity goEntity = default;

            Assert.DoesNotThrow(() => goEntity = GameObjectConversionUtility.ConvertGameObjectHierarchy(go, MakeDefaultSettings()));
            EntitiesAssert.Contains(m_Manager, EntityMatch.Exact <CodeGenManagedTestComponent>(goEntity, k_RootComponents));

            var prefabEntity = m_Manager.GetComponentData <CodeGenManagedTestComponent>(goEntity).Entities[0];

            EntitiesAssert.ContainsOnly(m_Manager,
                                        // gameobject created above
                                        EntityMatch.Exact <CodeGenManagedTestComponent>(goEntity, k_RootComponents),
                                        // referenced prefab
                                        EntityMatch.Exact <Prefab>(prefabEntity, new MockData(), k_RootComponents)
                                        );
        }
        public void LoadSceneAsync_LoadsAllSections()
        {
            using (var world = TestWorldSetup.CreateEntityWorld("World", false))
            {
                var manager     = world.EntityManager;
                var sceneSystem = world.GetOrCreateSystem <SceneSystem>();

                var resolveParams = new SceneSystem.LoadParameters
                {
                    Flags = SceneLoadFlags.BlockOnImport | SceneLoadFlags.BlockOnStreamIn
                };

                sceneSystem.LoadSceneAsync(SceneGUID, resolveParams);
                world.Update();

                EntitiesAssert.Contains(manager,
                                        EntityMatch.Partial(new SubSceneSectionTestData(42)),
                                        EntityMatch.Partial(new SubSceneSectionTestData(43)),
                                        EntityMatch.Partial(new SubSceneSectionTestData(44))
                                        );
            }
        }
        public void SetEnabledOnPrefabOnCompleteSet()
        {
            var entity   = ConvertGameObjectHierarchy(LoadPrefab("Prefab_Hierarchy"), MakeDefaultSettings());
            var instance = m_Manager.Instantiate(entity);

            EntitiesAssert.ContainsOnly(m_Manager,
                                        EntityMatch.Exact <Prefab>(new MockData(100), k_RootComponents, entity),
                                        EntityMatch.Exact <Prefab>(new MockData(101), k_ChildComponents),
                                        EntityMatch.Exact(new MockData(100), k_RootComponents, instance),
                                        EntityMatch.Exact(new MockData(101), k_ChildComponents));

            m_Manager.SetEnabled(instance, false);

            EntitiesAssert.Contains(m_Manager,
                                    EntityMatch.Exact <Disabled, MockData>(k_RootComponents, instance),
                                    EntityMatch.Exact <Disabled, MockData>(k_ChildComponents));

            m_Manager.SetEnabled(instance, true);

            EntitiesAssert.Contains(m_Manager,
                                    EntityMatch.Exact <MockData>(k_RootComponents, instance),
                                    EntityMatch.Exact <MockData>(k_ChildComponents));
        }
        public void GeneratedAuthoringComponent_WithReferencedPrefab_IsConverted()
        {
            var go = CreateGameObject();

            var authoringType = GetAuthoringComponentType <CodeGenTestComponent>();
            var c             = go.AddComponent(authoringType);

            authoringType.GetField(nameof(CodeGenTestComponent.Entity)).SetValue(c, LoadPrefab("Prefab"));

            Entity goEntity = default;

            Assert.DoesNotThrow(() => goEntity = GameObjectConversionUtility.ConvertGameObjectHierarchy(go, MakeDefaultSettings()));

            EntitiesAssert.Contains(m_Manager, EntityMatch.Exact <CodeGenTestComponent>(goEntity, k_RootComponents));
            var prefabEntity = m_Manager.GetComponentData <CodeGenTestComponent>(goEntity).Entity;

            EntitiesAssert.ContainsOnly(m_Manager,
                                        // gameobject created above
                                        EntityMatch.Exact <CodeGenTestComponent>(goEntity, k_RootComponents),
                                        // referenced prefab
                                        EntityMatch.Exact <Prefab>(prefabEntity, new MockData(), k_RootComponents)
                                        );
        }
        public void CanLoadSectionsIndividually()
        {
            using (var world = TestWorldSetup.CreateEntityWorld("World", false))
            {
                var manager     = world.EntityManager;
                var sceneSystem = world.GetOrCreateSystem <SceneSystem>();

                var resolveParams = new SceneSystem.LoadParameters
                {
                    Flags = SceneLoadFlags.BlockOnImport | SceneLoadFlags.BlockOnStreamIn | SceneLoadFlags.DisableAutoLoad
                };

                var subSceneSectionTestDataQuery = manager.CreateEntityQuery(typeof(SubSceneSectionTestData));

                var sceneEntity = sceneSystem.LoadSceneAsync(SceneGUID, resolveParams);
                world.Update();

                Assert.AreEqual(0, subSceneSectionTestDataQuery.CalculateEntityCount());

                var section0Entity  = FindSectionEntity(manager, sceneEntity, 0);
                var section10Entity = FindSectionEntity(manager, sceneEntity, 10);
                var section20Entity = FindSectionEntity(manager, sceneEntity, 20);
                Assert.AreNotEqual(Entity.Null, section0Entity);
                Assert.AreNotEqual(Entity.Null, section10Entity);
                Assert.AreNotEqual(Entity.Null, section20Entity);

                Assert.IsFalse(sceneSystem.IsSectionLoaded(section0Entity));
                Assert.IsFalse(sceneSystem.IsSectionLoaded(section10Entity));
                Assert.IsFalse(sceneSystem.IsSectionLoaded(section20Entity));

                manager.AddComponentData(section0Entity,
                                         new RequestSceneLoaded {
                    LoadFlags = SceneLoadFlags.BlockOnImport | SceneLoadFlags.BlockOnStreamIn
                });

                world.Update();

                Assert.IsTrue(sceneSystem.IsSectionLoaded(section0Entity));
                Assert.IsFalse(sceneSystem.IsSectionLoaded(section10Entity));
                Assert.IsFalse(sceneSystem.IsSectionLoaded(section20Entity));

                Assert.AreEqual(1, subSceneSectionTestDataQuery.CalculateEntityCount());
                Assert.AreEqual(42, subSceneSectionTestDataQuery.GetSingleton <SubSceneSectionTestData>().Value);

                manager.AddComponentData(section20Entity,
                                         new RequestSceneLoaded {
                    LoadFlags = SceneLoadFlags.BlockOnImport | SceneLoadFlags.BlockOnStreamIn
                });
                world.Update();

                Assert.IsTrue(sceneSystem.IsSectionLoaded(section0Entity));
                Assert.IsFalse(sceneSystem.IsSectionLoaded(section10Entity));
                Assert.IsTrue(sceneSystem.IsSectionLoaded(section20Entity));

                Assert.AreEqual(2, subSceneSectionTestDataQuery.CalculateEntityCount());
                EntitiesAssert.Contains(manager,
                                        EntityMatch.Partial(new SubSceneSectionTestData(42)),
                                        EntityMatch.Partial(new SubSceneSectionTestData(44)));


                manager.AddComponentData(section10Entity,
                                         new RequestSceneLoaded {
                    LoadFlags = SceneLoadFlags.BlockOnImport | SceneLoadFlags.BlockOnStreamIn
                });
                world.Update();

                Assert.IsTrue(sceneSystem.IsSectionLoaded(section0Entity));
                Assert.IsTrue(sceneSystem.IsSectionLoaded(section10Entity));
                Assert.IsTrue(sceneSystem.IsSectionLoaded(section20Entity));

                Assert.AreEqual(3, subSceneSectionTestDataQuery.CalculateEntityCount());
                EntitiesAssert.Contains(manager,
                                        EntityMatch.Partial(new SubSceneSectionTestData(42)),
                                        EntityMatch.Partial(new SubSceneSectionTestData(43)),
                                        EntityMatch.Partial(new SubSceneSectionTestData(44)));
            }
        }