private static (int Imported, int Skipped) ImportedArtboards(XdImportSettings xdSettings, AkyuiLogger logger, string xdFilePath, IAkyuiProgress progress, List <IAkyuiLoader> loaders) { logger.Log($"Xd Import Start"); var file = new XdFile(xdFilePath); var imported = 0; var skipped = 0; var targets = new List <XdArtboard>(); foreach (var artwork in file.Artworks) { if (artwork.Artboard.Children.Length == 0) { continue; } var markForExport = artwork.Artboard.Children[0].Meta?.Ux?.MarkedForExport ?? false; if (!markForExport) { continue; } targets.Add(artwork); } progress.SetTotal(targets.Count); foreach (var artwork in targets) { using (progress.TaskStart(artwork.Name)) { var akyuiXdObjectParsers = xdSettings.ObjectParsers ?? new AkyuiXdObjectParser[] { }; var akyuiXdGroupParsers = xdSettings.GroupParsers ?? new AkyuiXdGroupParser[] { }; var triggers = xdSettings.XdTriggers ?? new AkyuiXdImportTrigger[] { }; var name = artwork.Name; var xdHash = FastHash.CalculateHash(JsonConvert.SerializeObject(artwork.Artboard) + JsonConvert.SerializeObject(artwork.Resources)); var userData = new Dictionary <string, string> { { "xd_hash", xdHash.ToString() } }; var pathGetter = new PathGetter(xdSettings, name); var prevMetaGameObject = AssetDatabase.LoadAssetAtPath <GameObject>(pathGetter.MetaSavePath); var prevMeta = prevMetaGameObject != null?prevMetaGameObject.GetComponent <AkyuiMeta>() : null; var prevMetaUserData = prevMeta != null?prevMeta.FindUserData("xd_hash") : null; if (!xdSettings.ReimportLayout && !xdSettings.ReimportAsset && prevMetaUserData != null && prevMetaUserData.value == xdHash.ToString()) { logger.Log("Skip", ("hash", xdHash)); skipped++; continue; } loaders.Add(new XdAkyuiLoader(file, artwork, name, userData, akyuiXdObjectParsers, akyuiXdGroupParsers, triggers)); imported++; } } logger.Log($"Xd Import Finish", ("imported", imported), ("skipped", skipped)); return(imported, skipped); }
private (LayoutInfo, AssetsInfo) Create(XdArtboard xdArtboard, XdAssetHolder assetHolder, string name, Dictionary <string, string> userData) { var renderer = new XdRenderer(xdArtboard, assetHolder, _objectParsers, _groupParsers, _triggers); var layoutInfoForCalcHash = new LayoutInfo( name, 0, renderer.Meta, new Dictionary <string, string>(), renderer.Root, renderer.Elements.ToArray() ); var hash = FastHash.CalculateHash(JsonConvert.SerializeObject(AkyuiCompressor.ToSerializable(layoutInfoForCalcHash))); var layoutInfo = new LayoutInfo( name, hash, renderer.Meta, userData, renderer.Root, renderer.Elements.ToArray() ); var assetsInfo = new AssetsInfo( renderer.Assets.ToArray() ); return(layoutInfo, assetsInfo); }
public (IComponent[], IAsset[]) Render(XdObjectJson xdObject, XdAssetHolder assetHolder, IObbGetter obbGetter) { var components = new List <IComponent>(); var assets = new List <IAsset>(); var color = xdObject.GetFillUnityColor(); var svg = SvgUtil.CreateSvg(xdObject); xdObject.Group.Children = new XdObjectJson[] { }; var size = obbGetter.Get(xdObject).Size; var spriteUid = $"{xdObject.GetSimpleName()}_{xdObject.Id.Substring(0, 8)}.png"; var svgHash = FastHash.CalculateHash(svg); var cachedSvg = assetHolder.GetCachedSvg(svgHash); if (cachedSvg != null) { spriteUid = cachedSvg.SpriteUid; } else { assets.Add(new SpriteAsset(spriteUid, svgHash, size, null, null)); var xdImportSettings = XdImporter.Settings; assetHolder.Save(spriteUid, () => SvgToPng.Convert(svg, size, xdImportSettings)); assetHolder.SaveCacheSvg(spriteUid, svgHash); } components.Add(new ImageComponent( spriteUid, new Color(1f, 1f, 1f, color.a), Vector2Int.one )); return(components.ToArray(), assets.ToArray()); }
public Property FastHash_safe_and_unsafe_should_return_same_values(NonEmptyString str) { var s = str.Get; var safe = FastHash.OfString(s); var un = FastHash.OfStringFast(s); return((safe == un).Label("Safe and unsafe hash values should match")); }
/// <summary> /// Calculates the id string for a state represented by the supplied underlying NDA noces. /// </summary> /// <param name="states">The collection of underlying NDA states.</param> /// <param name="acceptState">The largest processed accept state so far.</param> /// <returns>The id</returns> public static ulong GetDfaId(ushort?acceptState, ICollection <NfaState> states) { var hasher = new FastHash(); foreach (var s in states) { hasher.Apply((ulong)s.NfaId); } hasher.Apply(0); if (acceptState.HasValue) { hasher.Apply(acceptState.Value); } return(hasher.Hash); }
public XdFile(string xdFilePath) { _zipFile = ZipFile.Open(xdFilePath, ZipArchiveMode.Read, Encoding.UTF8); var jsonObjectCache = new Dictionary <string, object>(); var jsonTextCache = new Dictionary <string, string>(); var manifestJsonString = _zipFile.ReadString("manifest"); var xdManifestJson = JsonSerializer.Deserialize <XdManifestJson>(manifestJsonString); var artworks = new List <XdArtboard>(); foreach (var xdManifestArtwork in xdManifestJson.Children.Single(x => x.Path == "artwork").Children) { var artworkJsonFilePath = $"artwork/{xdManifestArtwork.Path}/graphics/graphicContent.agc"; if (!jsonTextCache.ContainsKey(artworkJsonFilePath)) { jsonTextCache.Add(artworkJsonFilePath, _zipFile.ReadString(artworkJsonFilePath)); } var artworkJsonString = jsonTextCache[artworkJsonFilePath]; if (!jsonObjectCache.ContainsKey(artworkJsonFilePath)) { jsonObjectCache.Add(artworkJsonFilePath, JsonSerializer.Deserialize <XdArtboardJson>(artworkJsonString)); } var artworkJson = (XdArtboardJson)jsonObjectCache[artworkJsonFilePath]; var resourceJsonFilePath = artworkJson.Resources.Href.TrimStart('/'); if (!jsonTextCache.ContainsKey(resourceJsonFilePath)) { jsonTextCache.Add(resourceJsonFilePath, _zipFile.ReadString(resourceJsonFilePath)); } var resourcesJsonString = jsonTextCache[resourceJsonFilePath]; if (!jsonObjectCache.ContainsKey(resourceJsonFilePath)) { jsonObjectCache.Add(resourceJsonFilePath, JsonSerializer.Deserialize <XdResourcesJson>(resourcesJsonString)); } var resourceJson = (XdResourcesJson)jsonObjectCache[resourceJsonFilePath]; var xdHash = FastHash.CalculateHash(artworkJsonString + resourcesJsonString); artworks.Add(new XdArtboard(xdManifestArtwork.Name, xdManifestArtwork, artworkJson, resourceJson, xdHash)); } Artworks = artworks.ToArray(); }
public override void OnPreprocessAllAssets(IAkyuiLoader akyuiLoader, ref List <IAsset> assets) { _map = new Dictionary <string, string>(); var removed = new List <IAsset>(); var cache = new Dictionary <ulong, IAsset>(); foreach (var asset in assets) { if (!(asset is SpriteAsset spriteAsset)) { continue; } var hash = FastHash.CalculateHash(akyuiLoader.LoadAsset(spriteAsset.FileName).Select(x => (uint)x).ToArray()); if (!cache.ContainsKey(hash)) { cache.Add(hash, asset); continue; } var hit = cache[hash]; removed.Add(asset); _map[asset.FileName] = hit.FileName; } foreach (var r in removed) { assets.Remove(r); } if (removed.Count > 0) { Debug.Log($"[SameSpriteDetect] Remove {removed.Count} assets"); } }
protected override int Hash(string k) { return(FastHash.OfStringFast(_hashSeed + k + _hashSeed)); }
public int FastHash_OfStringUnsafe() { return(FastHash.OfStringFast(HashKey1)); }
public void TestFastHash64(string data, ulong seed, ulong expectedHash) { ulong hash = FastHash.Hash64(data.ToUtf8ByteArray(), seed); Assert.Equal(expectedHash, hash); }
public static (ImageComponent, IAsset[]) RenderImage(XdObjectJson xdObject, Obb obb, XdAssetHolder assetHolder) { ImageComponent imageComponent = null; SpriteAsset asset = null; var color = xdObject.GetFillUnityColor(); var ux = xdObject.Style?.Fill?.Pattern?.Meta?.Ux; var flipX = ux?.FlipX ?? false; var flipY = ux?.FlipY ?? false; var direction = new Vector2Int(flipX ? -1 : 1, flipY ? -1 : 1); var shapeType = xdObject.Shape?.Type; if (!string.IsNullOrWhiteSpace(ux?.Uid)) { var spriteUid = $"{xdObject.GetSimpleName()}_{ux?.Uid.Substring(0, 8)}.png"; asset = new SpriteAsset(spriteUid, xdObject.Style.Fill.Pattern.Meta.Ux.HrefLastModifiedDate, obb.Size, null, null); imageComponent = new ImageComponent( spriteUid, color, direction ); assetHolder.Save(spriteUid, xdObject.Style.Fill.Pattern.Meta); } else if (SvgUtil.Types.Contains(shapeType)) { var spriteUid = $"{xdObject.GetSimpleName()}_{xdObject.Id.Substring(0, 8)}.png"; var svg = SvgUtil.CreateSvg(xdObject); var svgHash = FastHash.CalculateHash(svg); var cachedSvg = assetHolder.GetCachedSvg(svgHash); if (cachedSvg != null) { spriteUid = cachedSvg.SpriteUid; } else { asset = new SpriteAsset(spriteUid, svgHash, obb.Size, null, null); var xdImportSettings = XdImporter.Settings; assetHolder.Save(spriteUid, () => SvgToPng.Convert(svg, obb.Size, xdImportSettings)); assetHolder.SaveCacheSvg(spriteUid, svgHash); } imageComponent = new ImageComponent( spriteUid, new Color(1f, 1f, 1f, color.a), direction ); } else { Debug.LogError($"Unknown shape type {shapeType} in {xdObject.Name}({xdObject.Id}, {xdObject.Guid})"); } var assets = new List <IAsset>(); if (!xdObject.HasParameter("placeholder") && asset != null) { assets.Add(asset); } return(imageComponent, assets.ToArray()); }
public int GetHashCode(string k) { return(FastHash.OfStringFast(_hashSeed != string.Empty ? _hashSeed + k + _hashSeed : k)); }
public void FastHashUnsafe(BenchmarkContext context) { FastHash.OfStringFast(HashCounterName); _hashOpCounter.Increment(); }
private string BuildUniqueId() { return(FastHash.Hash(GetHashSource() ?? Utils.GenerateRandomHexString())); }
public void TestFastHash32(string data, uint seed, uint expectedHash) { uint hash = FastHash.Hash32(data.ToUtf8ByteArray(), seed); Assert.Equal(expectedHash, hash); }
public int FastHash_OfString() { return(FastHash.OfString(HashKey1)); }
public void Execute(Script script) { var scriptName = _settings.Script.GetFilename(); var cacheDLLFileName = $"{scriptName}.dll"; var cacheHashFileName = $"{scriptName}.hash"; var cachedAssembly = _scriptCachePath.CombineWithFilePath(cacheDLLFileName); var hashFile = _scriptCachePath.CombineWithFilePath(cacheHashFileName); string scriptHash = default; if (_scriptCacheEnabled && _fileSystem.Exist(cachedAssembly) && !_regenerateCache) { _log.Verbose($"Cache enabled: Checking cache build script ({cacheDLLFileName})"); scriptHash = FastHash.GenerateHash(Encoding.UTF8.GetBytes(string.Concat(script.Lines))); var cachedHash = _fileSystem.Exist(hashFile) ? _fileSystem.GetFile(hashFile).ReadLines(Encoding.UTF8).FirstOrDefault() : string.Empty; if (scriptHash.Equals(cachedHash, StringComparison.Ordinal)) { _log.Verbose("Running cached build script..."); RunScriptAssembly(cachedAssembly.FullPath); return; } else { _log.Verbose("Cache check failed."); } } // Generate the script code. var generator = new RoslynCodeGenerator(); var code = generator.Generate(script); // Warn about any code generation excluded namespaces foreach (var @namespace in script.ExcludedNamespaces) { _log.Warning("Namespace {0} excluded by code generation, affected methods:\r\n\t{1}", @namespace.Key, string.Join("\r\n\t", @namespace.Value)); } // Create the script options dynamically. var options = Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default .AddImports(Namespaces.Except(script.ExcludedNamespaces.Keys)) .AddReferences(References) .AddReferences(ReferencePaths.Select(r => r.FullPath)) .WithEmitDebugInformation(_settings.Debug) .WithMetadataResolver(Microsoft.CodeAnalysis.Scripting.ScriptMetadataResolver.Default); var roslynScript = CSharpScript.Create(code, options, _host.GetType()); _log.Verbose("Compiling build script..."); var compilation = roslynScript.GetCompilation(); var diagnostics = compilation.GetDiagnostics(); var errors = new List <Diagnostic>(); foreach (var diagnostic in diagnostics) { // Suppress some diagnostic information. See https://github.com/cake-build/cake/issues/3337 switch (diagnostic.Id) { // CS1701 Compiler Warning (level 2) // Assuming assembly reference "Assembly Name #1" matches "Assembly Name #2", you may need to supply runtime policy // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/cs1701 case "CS1701": continue; // CS1702 Compiler Warning (level 3) // Assuming assembly reference "Assembly Name #1" matches "Assembly Name #2", you may need to supply runtime policy // https://docs.microsoft.com/en-us/dotnet/csharp/misc/cs1702 case "CS1702": continue; // CS1705 Compiler Error // Assembly 'AssemblyName1' uses 'TypeName' which has a higher version than referenced assembly 'AssemblyName2' case "CS1705": continue; default: break; } switch (diagnostic.Severity) { case DiagnosticSeverity.Info: _log.Information(diagnostic.ToString()); break; case DiagnosticSeverity.Warning: _log.Warning(diagnostic.ToString()); break; case DiagnosticSeverity.Error: _log.Error(diagnostic.ToString()); errors.Add(diagnostic); break; default: break; } } if (errors.Any()) { var errorMessages = string.Join(Environment.NewLine, errors.Select(x => x.ToString())); var message = string.Format(CultureInfo.InvariantCulture, "Error(s) occurred when compiling build script:{0}{1}", Environment.NewLine, errorMessages); throw new CakeException(message); } if (_scriptCacheEnabled) { // Verify cache directory exists if (!_fileSystem.GetDirectory(_scriptCachePath).Exists) { _fileSystem.GetDirectory(_scriptCachePath).Create(); } if (string.IsNullOrWhiteSpace(scriptHash)) { scriptHash = FastHash.GenerateHash(Encoding.UTF8.GetBytes(string.Concat(script.Lines))); } var emitResult = compilation.Emit(cachedAssembly.FullPath); if (emitResult.Success) { using (var stream = _fileSystem.GetFile(hashFile).OpenWrite()) using (var writer = new StreamWriter(stream, Encoding.UTF8)) { writer.Write(scriptHash); } RunScriptAssembly(cachedAssembly.FullPath); } } else { roslynScript.RunAsync(_host).GetAwaiter().GetResult(); } }
// Renderは親から子供の順番 private IElement[] Render(XdObjectJson xdObject, [CanBeNull] Obb parentObb, XdObjectJson[] parents) { var eid = FastHash.CalculateHash(xdObject.Guid ?? xdObject.Id); var originalObb = _obbHolder.Get(xdObject); var obb = originalObb.CalcObbInWorld(parentObb); var position = obb.CalcLocalRect().center - (parentObb?.Size ?? Vector2.zero) / 2f; var size = obb.Size; var anchorX = AnchorXType.Center; var anchorY = AnchorYType.Middle; var rotation = obb.Rotation; if (Mathf.Abs(rotation) < 0.0001f) { rotation = 0f; } var constRight = xdObject.Meta.Ux.ConstraintRight; var constLeft = xdObject.Meta.Ux.ConstraintLeft; if (constRight && constLeft) { anchorX = AnchorXType.Stretch; } else if (constRight) { anchorX = AnchorXType.Right; } else if (constLeft) { anchorX = AnchorXType.Left; } var constTop = xdObject.Meta.Ux.ConstraintTop; var constBottom = xdObject.Meta.Ux.ConstraintBottom; if (constTop && constBottom) { anchorY = AnchorYType.Stretch; } else if (constTop) { anchorY = AnchorYType.Top; } else if (constBottom) { anchorY = AnchorYType.Bottom; } foreach (var parser in _objectParsers) { if (!parser.Is(xdObject)) { continue; } var(components, assets) = parser.Render(xdObject, obb, _xdAssetHolder); var children = new IElement[] { }; if (xdObject.Group != null) { children = Render(xdObject.Group.Children, originalObb, parents.Concat(new[] { xdObject }).ToArray()); } var element = new ObjectElement( eid, xdObject.GetSimpleName(), position, size, anchorX, anchorY, rotation, xdObject.Visible ?? true, components, children.Select(x => x.Eid).ToArray() ); foreach (var asset in assets) { if (Assets.Any(x => x.FileName == asset.FileName)) { continue; } Assets.Add(asset); } Elements.Add(element); return(new IElement[] { element }); } if (xdObject.Type == "group") { var components = new List <IComponent>(); foreach (var parser in _groupParsers) { if (!parser.Is(xdObject, parents)) { continue; } var(c, assets) = parser.Render(xdObject, _xdAssetHolder, _obbHolder); components.AddRange(c); foreach (var asset in assets) { if (Assets.Any(x => x.FileName == asset.FileName)) { continue; } Assets.Add(asset); } break; } var generatedChildren = new IElement[] { }; if (xdObject.Group != null) { generatedChildren = Render(xdObject.Group.Children, originalObb, parents.Concat(new[] { xdObject }).ToArray()); } var group = new ObjectElement( eid, xdObject.GetSimpleName(), position, size, anchorX, anchorY, rotation, xdObject.Visible ?? true, components.ToArray(), generatedChildren.Select(x => x.Eid).ToArray() ); Elements.Add(group); return(new IElement[] { group }); } throw new Exception($"Unknown object type {xdObject.Type}"); }