/// <summary> /// Returns the absolute path on the disk of an <see cref="UFile"/> that is relative to the asset location. /// </summary> /// <param name="assetItem">The asset on which is based the relative path.</param> /// <param name="relativePath">The path relative to the asset path that must be converted to an absolute path.</param> /// <returns>The absolute path on the disk of the <see cref="relativePath"/> argument.</returns> /// <exception cref="ArgumentException">The <see cref="relativePath"/> argument is a null or empty <see cref="UFile"/>.</exception> protected static UFile GetAbsolutePath(AssetItem assetItem, UFile relativePath) { if (string.IsNullOrEmpty(relativePath)) throw new ArgumentException("The relativePath argument is null or empty"); var assetDirectory = assetItem.FullPath.GetParent(); var assetSource = UPath.Combine(assetDirectory, relativePath); return assetSource; }
public object Load(Stream stream, UFile filePath, ILogger log, out bool aliasOccurred, out Dictionary<YamlAssetPath, OverrideType> overrides) { aliasOccurred = false; var assetFileExtension = filePath.GetFileExtension().ToLowerInvariant(); var type = AssetRegistry.GetAssetTypeFromFileExtension(assetFileExtension); var asset = (SourceCodeAsset)Activator.CreateInstance(type); var textAccessor = asset.TextAccessor as SourceCodeAsset.DefaultTextAccessor; if (textAccessor != null) { // Don't load the file if we have the file path textAccessor.FilePath = filePath; // Set the assets text if it loaded from an in-memory version // TODO: Propagate dirtiness? if (stream is MemoryStream) { var reader = new StreamReader(stream, Encoding.UTF8); textAccessor.Set(reader.ReadToEnd()); } } // No override in source code assets overrides = new Dictionary<YamlAssetPath, OverrideType>(); return asset; }
/// <summary> /// Initializes a new instance of the <see cref="AssetToImport"/> class. /// </summary> /// <param name="file">The file.</param> /// <exception cref="System.ArgumentNullException">file</exception> internal AssetToImport(UFile file) { if (file == null) throw new ArgumentNullException("file"); this.file = file; ByImporters = new List<AssetToImportByImporter>(); Enabled = true; }
public static bool IsSupportingFile(this IAssetImporter importer, UFile file) { if (file == null) throw new ArgumentNullException("file"); if (file.GetFileExtension() == null) return false; return FileUtility.GetFileExtensionsAsSet(importer.SupportedFileExtensions).Contains(file.GetFileExtension()); }
/// <summary> /// Initializes a new instance of the <see cref="SettingsEntry"/> class. /// </summary> /// <param name="profile">The profile this <see cref="SettingsEntry"/>belongs to.</param> /// <param name="name">The name associated to this <see cref="SettingsEntry"/>.</param> protected SettingsEntry(SettingsProfile profile, UFile name) { if (profile == null) throw new ArgumentNullException("profile"); if (name == null) throw new ArgumentNullException("name"); Profile = profile; Name = name; }
public static EntityHierarchyData ImportScene(UFile sourceUrl, EntityGroupAssetBase source, Guid sourceRootEntity) { if (source == null) throw new ArgumentNullException("source"); // Extract the scene starting from given root var newAsset = ExtractSceneClone(source, sourceRootEntity); // Generate entity mapping var reverseEntityMapping = new Dictionary<Guid, Guid>(); foreach (var entityDesign in newAsset.Hierarchy.Entities) { // Generate new Id var newEntityId = Guid.NewGuid(); // Update mappings reverseEntityMapping.Add(entityDesign.Entity.Id, newEntityId); // Update entity with new id entityDesign.Entity.Id = newEntityId; } // Rewrite entity references // Should we nullify invalid references? EntityAnalysis.RemapEntitiesId(newAsset.Hierarchy, reverseEntityMapping); return newAsset.Hierarchy; }
public void TestUpdateAssetUrl() { var projectDir = new UFile(Path.Combine(Environment.CurrentDirectory, "testxk")); // Create a project with an asset reference a raw file var project = new Package { FullPath = projectDir }; var assetItem = new AssetItem("test", new AssetObjectTest() { Reference = new AssetReference<AssetObjectTest>(Guid.Empty, "good/location")}); project.Assets.Add(assetItem); var goodAsset = new AssetObjectTest(); project.Assets.Add(new AssetItem("good/location", goodAsset)); // Add the project to the session to make sure analysis will run correctly var session = new PackageSession(project); // Create a session with this project var analysis = new PackageAnalysis(project, new PackageAnalysisParameters() { IsProcessingAssetReferences = true, ConvertUPathTo = UPathType.Absolute, IsProcessingUPaths = true }); var result = analysis.Run(); Assert.IsFalse(result.HasErrors); Assert.AreEqual(1, result.Messages.Count); Assert.IsTrue(result.Messages[0].ToString().Contains("changed")); var asset = (AssetObjectTest)assetItem.Asset; Assert.AreEqual(goodAsset.Id, asset.Reference.Id); Assert.AreEqual("good/location", asset.Reference.Location); }
protected override Task<ResultStatus> DoCommandOverride(ICommandContext commandContext) { // This path for effects xml is now part of this tool, but it should be done in a separate exporter? using (var inputStream = File.OpenRead(SourcePath)) using (var outputStream = AssetManager.FileProvider.OpenStream(Location, VirtualFileMode.Create, VirtualFileAccess.Write)) { inputStream.CopyTo(outputStream); var objectURL = new ObjectUrl(UrlType.ContentLink, Location); if (DisableCompression) commandContext.AddTag(objectURL, DisableCompressionSymbol); } if (SaveSourcePath) { // store absolute path to source // TODO: the "/path" is hardcoded, used in EffectSystem and ShaderSourceManager. Find a place to share this correctly. var pathLocation = new UFile(Location.FullPath + "/path"); using (var outputStreamPath = AssetManager.FileProvider.OpenStream(pathLocation, VirtualFileMode.Create, VirtualFileAccess.Write)) { using (var sw = new StreamWriter(outputStreamPath)) { sw.Write(SourcePath.FullPath); } } } return Task.FromResult(ResultStatus.Successful); }
public object Load(Stream stream, UFile filePath, ILogger log, out bool aliasOccurred, out Dictionary<YamlAssetPath, OverrideType> overrides) { PropertyContainer properties; var result = AssetYamlSerializer.Default.Deserialize(stream, null, log != null ? new SerializerContextSettings { Logger = log } : null, out aliasOccurred, out properties); properties.TryGetValue(AssetObjectSerializerBackend.OverrideDictionaryKey, out overrides); return result; }
/// <summary> /// Initializes a new instance of the <see cref="SettingsKey"/> class. /// </summary> /// <param name="name">The name of this settings key. Must be unique amongst the application.</param> /// <param name="group">The <see cref="SettingsGroup"/> containing this <see cref="SettingsKey"/>.</param> /// <param name="defaultValueCallback">A function that returns the default value associated to this settings key.</param> protected SettingsKey(UFile name, SettingsGroup group, Func<object> defaultValueCallback) { Name = name; DisplayName = name; DefaultObjectValueCallback = defaultValueCallback; Group = group; Group.RegisterSettingsKey(name, defaultValueCallback(), this); }
/// <summary> /// Initializes a new instance of the <see cref="SettingsKey"/> class. /// </summary> /// <param name="name">The name of this settings key. Must be unique amongst the application.</param> /// <param name="group">The <see cref="SettingsGroup"/> containing this <see cref="SettingsKey"/>.</param> /// <param name="defaultValue">The default value associated to this settings key.</param> protected SettingsKey(UFile name, SettingsGroup group, object defaultValue) { Name = name; DisplayName = name; DefaultObjectValue = defaultValue; Group = group; Group.RegisterSettingsKey(name, defaultValue, this); }
/// <summary> /// Initializes a new instance of the <see cref="PackageLoadingAssetFile" /> class. /// </summary> /// <param name="package">The package this asset will be part of.</param> /// <param name="filePath">The relative file path (from default asset folder).</param> /// <param name="sourceFolder">The source folder (optional, can be null).</param> /// <exception cref="System.ArgumentException">filePath must be relative</exception> public PackageLoadingAssetFile(Package package, UFile filePath, UDirectory sourceFolder) { if (filePath.IsAbsolute) throw new ArgumentException("filePath must be relative", filePath); SourceFolder = UPath.Combine(package.RootDirectory, sourceFolder ?? package.GetDefaultAssetFolder()); FilePath = UPath.Combine(SourceFolder, filePath); }
/// <summary> /// Initializes a new instance of the <see cref="SettingsKey"/> class. /// </summary> /// <param name="name">The name of this settings key. Must be unique amongst the application.</param> /// <param name="container">The <see cref="SettingsContainer"/> containing this <see cref="SettingsKey"/>.</param> /// <param name="defaultValueCallback">A function that returns the default value associated to this settings key.</param> protected SettingsKey(UFile name, SettingsContainer container, Func<object> defaultValueCallback) { Name = name; DisplayName = name; DefaultObjectValueCallback = defaultValueCallback; Container = container; Container.RegisterSettingsKey(name, defaultValueCallback(), this); }
/// <summary> /// Initializes a new instance of the <see cref="SettingsKey"/> class. /// </summary> /// <param name="name">The name of this settings key. Must be unique amongst the application.</param> /// <param name="container">The <see cref="SettingsContainer"/> containing this <see cref="SettingsKey"/>.</param> /// <param name="defaultValue">The default value associated to this settings key.</param> protected SettingsKey(UFile name, SettingsContainer container, object defaultValue) { Name = name; DisplayName = name; DefaultObjectValue = defaultValue; Container = container; Container.RegisterSettingsKey(name, defaultValue, this); }
public virtual bool IsSupportingFile(string filePath) { if (filePath == null) throw new ArgumentNullException("filePath"); var file = new UFile(filePath); if (file.GetFileExtension() == null) return false; return FileUtility.GetFileExtensionsAsSet(SupportedFileExtensions).Contains(file.GetFileExtension()); }
/// <summary> /// Imports the model. /// </summary> /// <param name="localPath">The path of the asset.</param> /// <param name="importParameters">The parameters used to import the model.</param> /// <returns>A collection of assets.</returns> public override IEnumerable<AssetItem> Import(UFile localPath, AssetImporterParameters importParameters) { var rawAssetReferences = new List<AssetItem>(); // the asset references without subdirectory path var entityInfo = GetEntityInfo(localPath, importParameters.Logger); //var isImportingEntity = importParameters.IsTypeSelectedForOutput<EntityAsset>(); var isImportingModel = importParameters.IsTypeSelectedForOutput<ModelAsset>(); var isImportingMaterial = importParameters.IsTypeSelectedForOutput<MaterialAsset>() || isImportingModel; var isImportingTexture = importParameters.IsTypeSelectedForOutput<TextureAsset>() || isImportingMaterial; // 1. Textures if (isImportingTexture) { ImportTextures(entityInfo.TextureDependencies, rawAssetReferences); } // 2. Skeleton AssetItem skeletonAsset = null; if (importParameters.IsTypeSelectedForOutput<SkeletonAsset>()) { skeletonAsset = ImportSkeleton(rawAssetReferences, localPath, localPath, entityInfo); } // 3. Animation if (importParameters.IsTypeSelectedForOutput<AnimationAsset>()) { ImportAnimation(rawAssetReferences, localPath, entityInfo.AnimationNodes, isImportingModel, skeletonAsset); } // 4. Materials if (isImportingMaterial) { ImportMaterials(rawAssetReferences, entityInfo.Materials); } // 5. Model if (isImportingModel) { var modelItem = ImportModel(rawAssetReferences, localPath, localPath, entityInfo, false, skeletonAsset); // 5. Entity (currently disabled) //if (isImportingEntity) //{ // var entityAssetItem = ImportEntity(rawAssetReferences, localPath, modelItem); // // // Apply EntityAnalysis // EntityAnalysis.UpdateEntityReferences(((EntityAsset)entityAssetItem.Asset).Hierarchy); //} } return rawAssetReferences; }
public override IEnumerable<AssetItem> Import(UFile rawAssetPath, AssetImporterParameters importParameters) { var asset = new TextureAsset { Source = rawAssetPath }; // Creates the url to the texture var textureUrl = new UFile(rawAssetPath.GetFileName(), null); yield return new AssetItem(textureUrl, asset); }
/// <summary> /// Finds a name available for a new asset. This method will try to create a name based on an existing name and will append /// "_" + (number++) on every try. The new location found is added to the known existing locations. /// </summary> /// <param name="location">The location.</param> /// <param name="newLocation">The new location.</param> /// <returns><c>true</c> if there is a new location, <c>false</c> otherwise.</returns> public bool RegisterLocation(UFile location, out UFile newLocation) { newLocation = location; if (IsContainingLocation(location)) { newLocation = NamingHelper.ComputeNewName(location, IsContainingLocation); } ExistingLocations.Add(newLocation); return newLocation != location; }
/// <inheritdoc/> protected override Task<ResultStatus> DoCommandOverride(ICommandContext commandContext) { var gameSettings = context.GetGameSettingsAsset(); // Find default scene URL var defaultSceneUrl = gameSettings.DefaultScene != null ? AttachedReferenceManager.GetUrl(gameSettings.DefaultScene) : null; if (defaultSceneUrl == null) return Task.FromResult(ResultStatus.Successful); var baseUrl = new UFile(defaultSceneUrl).GetParent(); try { commandContext.Logger.Info($"Trying to compile effects for scene '{defaultSceneUrl}'"); using (var sceneRenderer = new SceneRenderer(gameSettings)) { // Effect can be compiled asynchronously (since we don't have any fallback, they will have to be compiled in the same frame anyway) // Also set the file provider to the current transaction ((EffectCompilerCache)sceneRenderer.EffectSystem.Compiler).CompileEffectAsynchronously = true; ((EffectCompilerCache)sceneRenderer.EffectSystem.Compiler).FileProvider = MicrothreadLocalDatabases.DatabaseFileProvider; ((EffectCompilerCache)sceneRenderer.EffectSystem.Compiler).CurrentCache = EffectBytecodeCacheLoadSource.StartupCache; sceneRenderer.EffectSystem.EffectUsed += (effectCompileRequest, result) => compilerResult.BuildSteps.Add(EffectCompileCommand.FromRequest(context, package, baseUrl, effectCompileRequest)); sceneRenderer.GameSystems.LoadContent(); // Load the scene var scene = sceneRenderer.ContentManager.Load<Scene>(defaultSceneUrl); sceneRenderer.SceneSystem.SceneInstance = new SceneInstance(sceneRenderer.Services, scene, ExecutionMode.EffectCompile); // Disable culling sceneRenderer.SceneSystem.SceneInstance.VisibilityGroups.CollectionChanged += (sender, e) => { if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add) { ((VisibilityGroup)e.Item).DisableCulling = true; } }; // Update and draw // This will force effects to be generated and saved in the object database var time = new GameTime(); sceneRenderer.GameSystems.Update(time); sceneRenderer.GraphicsContext.ResourceGroupAllocator.Reset(sceneRenderer.GraphicsContext.CommandList); sceneRenderer.GameSystems.Draw(time); } } catch (Exception e) { commandContext.Logger.Warning($"Could not compile effects for scene '{defaultSceneUrl}': {e.Message + e.StackTrace}", e); } return Task.FromResult(ResultStatus.Successful); }
private void ChangeFileExtension(IList<PackageLoadingAssetFile> assetFiles, PackageLoadingAssetFile file, string newExtension) { // Create the new file var newFileName = new UFile(file.FilePath.FullPath.Replace(file.FilePath.GetFileExtension(), ".pdxsheet")); var newFile = new PackageLoadingAssetFile(newFileName, file.SourceFolder) { AssetContent = file.AssetContent }; // Add the new file assetFiles.Add(newFile); // Mark the old file as "To Delete" file.Deleted = true; }
public override IEnumerable<AssetItem> Import(UFile rawAssetPath, AssetImporterParameters importParameters) { var outputAssets = new List<AssetItem>(); if (!SpriteStudioXmlImport.SanityCheck(rawAssetPath)) { importParameters.Logger.Error("Invalid xml file or some required files are missing."); return null; } //pre-process models var nodes = new List<SpriteStudioNode>(); string modelName; if (!SpriteStudioXmlImport.ParseModel(rawAssetPath, nodes, out modelName)) { importParameters.Logger.Error("Failed to parse Sprite Studio model."); return null; } if (importParameters.IsTypeSelectedForOutput<SpriteStudioModelAsset>()) { var model = new SpriteStudioModelAsset { Source = rawAssetPath }; foreach (var node in nodes) { model.NodeNames.Add(node.Name); } outputAssets.Add(new AssetItem(modelName, model)); } if (importParameters.IsTypeSelectedForOutput<SpriteStudioAnimationAsset>()) { //pre-process anims var anims = new List<SpriteStudioAnim>(); if (!SpriteStudioXmlImport.ParseAnimations(rawAssetPath, anims)) { importParameters.Logger.Error("Failed to parse Sprite Studio animations."); return null; } foreach (var studioAnim in anims) { var anim = new SpriteStudioAnimationAsset { Source = rawAssetPath, AnimationName = studioAnim.Name }; outputAssets.Add(new AssetItem(modelName + "_" + studioAnim.Name, anim)); } } return outputAssets; }
/// <summary> /// Imports the model. /// </summary> /// <param name="localPath">The path of the asset.</param> /// <param name="importParameters">The parameters used to import the model.</param> /// <returns>A collection of assets.</returns> public override IEnumerable<AssetItem> Import(UFile localPath, AssetImporterParameters importParameters) { var rawAssetReferences = new List<AssetItem>(); // the asset references without subdirectory path var entityInfo = GetEntityInfo(localPath, importParameters.Logger, importParameters); //var isImportingEntity = importParameters.IsTypeSelectedForOutput<PrefabAsset>(); var isImportingModel = importParameters.IsTypeSelectedForOutput<ModelAsset>(); var isImportingMaterial = importParameters.IsTypeSelectedForOutput<MaterialAsset>(); var isImportingTexture = importParameters.IsTypeSelectedForOutput<TextureAsset>(); // 1. Textures if (isImportingTexture) { ImportTextures(entityInfo.TextureDependencies, rawAssetReferences); } // 2. Skeleton AssetItem skeletonAsset = null; if (importParameters.IsTypeSelectedForOutput<SkeletonAsset>()) { skeletonAsset = ImportSkeleton(rawAssetReferences, localPath, localPath, entityInfo); } // 3. Animation if (importParameters.IsTypeSelectedForOutput<AnimationAsset>()) { ImportAnimation(rawAssetReferences, localPath, entityInfo.AnimationNodes, isImportingModel, skeletonAsset); } // 4. Materials if (isImportingMaterial) { ImportMaterials(rawAssetReferences, entityInfo.Materials); } // 5. Model if (isImportingModel) { ImportModel(rawAssetReferences, localPath, localPath, entityInfo, false, skeletonAsset); } return rawAssetReferences; }
public void TestMoveAssetWithUFile() { var projectDir = new UFile(Path.Combine(Environment.CurrentDirectory, "testxk")); var rawAssetPath = new UFile("../image.png"); var assetPath = new UFile("sub1/sub2/test"); // Create a project with an asset reference a raw file var project = new Package { FullPath = projectDir }; project.Profiles.Add(new PackageProfile("Shared", new AssetFolder("."))); var asset = new AssetObjectTest() { RawAsset = new UFile(rawAssetPath) }; var assetItem = new AssetItem(assetPath, asset); project.Assets.Add(assetItem); // Run an asset reference analysis on this project var analysis = new PackageAnalysis(project, new PackageAnalysisParameters() { ConvertUPathTo = UPathType.Absolute, IsProcessingUPaths = true }); var result = analysis.Run(); Assert.IsFalse(result.HasErrors); Assert.AreEqual(UPath.Combine(project.RootDirectory, new UFile("sub1/image.png")), asset.RawAsset); project.Assets.Remove(assetItem); assetItem = new AssetItem("sub1/test", asset); project.Assets.Add(assetItem); result = analysis.Run(); Assert.IsFalse(result.HasErrors); Assert.AreEqual(UPath.Combine(project.RootDirectory, new UFile("sub1/image.png")), asset.RawAsset); project.Assets.Remove(assetItem); assetItem = new AssetItem("test", asset); project.Assets.Add(assetItem); result = analysis.Run(); Assert.IsFalse(result.HasErrors); Assert.AreEqual(UPath.Combine(project.RootDirectory, new UFile("sub1/image.png")), asset.RawAsset); analysis.Parameters.ConvertUPathTo = UPathType.Relative; result = analysis.Run(); Assert.IsFalse(result.HasErrors); Assert.AreEqual(new UFile("sub1/image.png"), asset.RawAsset); }
/// <summary> /// Generate a precompiled sprite font from the current sprite font asset. /// </summary> /// <param name="asset">The sprite font asset</param> /// <param name="sourceAsset">The source sprite font asset item</param> /// <param name="texturePath">The path of the source texture</param> /// <param name="srgb">Indicate if the generated texture should be srgb</param> /// <returns>The precompiled sprite font asset</returns> public static PrecompiledSpriteFontAsset GeneratePrecompiledSDFSpriteFont(this SpriteFontAsset asset, AssetItem sourceAsset, string texturePath) { // TODO create PrecompiledSDFSpriteFontAsset var scalableFont = (SignedDistanceFieldSpriteFont)SignedDistanceFieldFontCompiler.Compile(FontDataFactory, asset); var referenceToSourceFont = new AssetReference<SpriteFontAsset>(sourceAsset.Id, sourceAsset.Location); var glyphs = new List<Glyph>(scalableFont.CharacterToGlyph.Values); var textures = scalableFont.Textures; var imageType = ImageFileType.Png; var textureFileName = new UFile(texturePath).GetFullPathWithoutExtension() + imageType.ToFileExtension(); if (textures != null && textures.Count > 0) { // save the texture TODO support for multi-texture using (var stream = File.OpenWrite(textureFileName)) scalableFont.Textures[0].GetSerializationData().Save(stream, imageType); } var precompiledAsset = new PrecompiledSpriteFontAsset { Glyphs = glyphs, Size = asset.FontType.Size, Style = asset.FontSource.Style, OriginalFont = referenceToSourceFont, FontDataFile = textureFileName, BaseOffset = scalableFont.BaseOffsetY, DefaultLineSpacing = scalableFont.DefaultLineSpacing, ExtraSpacing = scalableFont.ExtraSpacing, ExtraLineSpacing = scalableFont.ExtraLineSpacing, DefaultCharacter = asset.DefaultCharacter, FontName = asset.FontSource.GetFontName(), IsPremultiplied = asset.FontType.IsPremultiplied, IsSrgb = false, }; return precompiledAsset; }
/// <summary> /// Generate a precompiled sprite font from the current sprite font asset. /// </summary> /// <param name="asset">The sprite font asset</param> /// <param name="sourceAsset">The source sprite font asset item</param> /// <param name="texturePath">The path of the source texture</param> /// <param name="srgb">Indicate if the generated texture should be srgb</param> /// <returns>The precompiled sprite font asset</returns> public static PrecompiledSpriteFontAsset GeneratePrecompiledSpriteFont(this SpriteFontAsset asset, AssetItem sourceAsset, string texturePath, bool srgb) { var staticFont = (StaticSpriteFont)StaticFontCompiler.Compile(FontDataFactory, asset, srgb); var referenceToSourceFont = new AssetReference<SpriteFontAsset>(sourceAsset.Id, sourceAsset.Location); var glyphs = new List<Glyph>(staticFont.CharacterToGlyph.Values); var textures = staticFont.Textures; var imageType = ImageFileType.Png; var textureFileName = new UFile(texturePath).GetFullPathWithoutExtension() + imageType.ToFileExtension(); if (textures != null && textures.Count > 0) { // save the texture TODO support for multi-texture using (var stream = File.OpenWrite(textureFileName)) staticFont.Textures[0].GetSerializationData().Save(stream, imageType); } var precompiledAsset = new PrecompiledSpriteFontAsset { Glyphs = glyphs, Size = asset.Size, Style = asset.Style, Source = referenceToSourceFont, FontDataFile = textureFileName, BaseOffset = staticFont.BaseOffsetY, DefaultLineSpacing = staticFont.DefaultLineSpacing, ExtraSpacing = staticFont.ExtraSpacing, ExtraLineSpacing = staticFont.ExtraLineSpacing, DefaultCharacter = asset.DefaultCharacter, FontName = !string.IsNullOrEmpty(asset.Source) ? (asset.Source.GetFileName() ?? "") : asset.FontName, IsPremultiplied = asset.IsPremultiplied, IsSrgb = srgb }; return precompiledAsset; }
public SpriteFontAsset() { DefaultCharacter = ' '; Style = FontStyle.Regular; CharacterRegions = new List<CharacterRegion>(); LineGapFactor = 1.0f; LineGapBaseLineFactor = 1.0f; Source = new UFile(""); CharacterSet = new UFile(""); }
public static UFile Combine([NotNull] UDirectory leftPath, [NotNull] UFile rightPath) { return(UPath.Combine(leftPath, rightPath)); }
/// <inheritdoc/> public override EntityInfo GetEntityInfo(UFile localPath, Logger logger) { var meshConverter = new Importer.FBX.MeshConverter(logger); var entityInfo = meshConverter.ExtractEntity(localPath.FullPath); return entityInfo; }
/// <summary> /// Retrieves Url for a texture given absolute path and sprite index /// </summary> /// <param name="textureAbsolutePath">Absolute Url of a texture</param> /// <param name="spriteIndex">Sprite index</param> public static string BuildTextureUrl(UFile textureAbsolutePath, int spriteIndex) { return textureAbsolutePath + "__IMAGE_TEXTURE__" + spriteIndex; }
/// <summary> /// Initializes a new instance of the <see cref="PackageLoadingAssetFile"/> class. /// </summary> /// <param name="filePath">The file path.</param> /// <param name="sourceFolder">The source folder.</param> public PackageLoadingAssetFile(UFile filePath, UDirectory sourceFolder) { FilePath = filePath; SourceFolder = sourceFolder; }
/// <summary> /// Retrieves Url for an atlas texture given absolute path and atlas index /// </summary> /// <param name="textureAbsolutePath">Absolute Url of an atlas texture</param> /// <param name="atlasIndex">Atlas index</param> public static string BuildTextureAtlasUrl(UFile textureAbsolutePath, int atlasIndex) { return textureAbsolutePath + "__ATLAS_TEXTURE__" + atlasIndex; }