internal static void CalculateTargetDependencies(Entities.Hash128 artifactHash, BuildTarget target, out ResolvedAssetID[] dependencies, ImportMode syncMode)
        {
            List <Entities.Hash128> assets = new List <Entities.Hash128>(LiveLinkBuildImporter.GetDependenciesInternal(artifactHash));
            List <ResolvedAssetID>  resolvedDependencies = new List <ResolvedAssetID>();

            HashSet <Entities.Hash128> visited = new HashSet <Entities.Hash128>();

            for (int i = 0; i < assets.Count; i++)
            {
                if (!visited.Add(assets[i]))
                {
                    continue;
                }

                var resolvedAsset = new ResolvedAssetID
                {
                    GUID       = assets[i],
                    TargetHash = CalculateTargetHash(assets[i], target, syncMode),
                };
                resolvedDependencies.Add(resolvedAsset);

                if (resolvedAsset.TargetHash.IsValid)
                {
                    assets.AddRange(LiveLinkBuildImporter.GetDependenciesInternal(resolvedAsset.TargetHash));
                }
            }

            dependencies = resolvedDependencies.ToArray();
        }
Example #2
0
        //@TODO There must be a more efficient way
        static Entity GetPublicRefEntity(EntityManager manager, Entities.Hash128 guid)
        {
            using (var sceneDataGrp = manager.CreateEntityQuery(typeof(SceneSectionData)))
            {
                using (var sceneEntities = sceneDataGrp.ToEntityArray(Allocator.TempJob))
                {
                    foreach (var sceneEntity in sceneEntities)
                    {
                        var scenedata = manager.GetComponentData <SceneSectionData>(sceneEntity);
                        if (scenedata.SceneGUID == guid && scenedata.SubSectionIndex == 0)
                        {
                            using (var group = manager.CreateEntityQuery(typeof(SceneTag), typeof(PublicEntityRef)))
                            {
                                group.SetSharedComponentFilter(new SceneTag {
                                    SceneEntity = sceneEntity
                                });
                                using (var entities = group.ToEntityArray(Allocator.TempJob))
                                {
                                    return(entities.Length > 0 ? entities[0] : Entity.Null);
                                }
                            }
                        }
                    }
                }
            }

            return(Entity.Null);
        }
Example #3
0
        public static unsafe void WriteBootstrap(string path, Entities.Hash128 buildConfigurationGUID)
        {
            long handshakeId = GetEditorLiveLinkId();

            using (var stream = new StreamBinaryWriter(path))
            {
                stream.WriteBytes(&buildConfigurationGUID, sizeof(GUID));
                stream.WriteBytes(&handshakeId, sizeof(long));
            }
        }
Example #4
0
        private static unsafe void ReadBootstrap()
        {
            var path = bootstrapPath;

            using (var rdr = new StreamBinaryReader(path))
            {
                Entities.Hash128 guid = default;
                long             id   = 0;

                rdr.ReadBytes(&guid, sizeof(Entities.Hash128));
                rdr.ReadBytes(&id, sizeof(long));

                BuildConfigurationGUID = guid;
                LiveLinkId             = id;
            }
        }