public void OnGroupAtlases(BuildTarget target, PackerJob job, int[] textureImporterInstanceIDs) { List<Entry> entries = new List<Entry>(); foreach (int instanceID in textureImporterInstanceIDs) { TextureImporter ti = EditorUtility.InstanceIDToObject(instanceID) as TextureImporter; //TextureImportInstructions ins = new TextureImportInstructions(); //ti.ReadTextureImportInstructions(ins, target); TextureImporterSettings tis = new TextureImporterSettings(); ti.ReadTextureSettings(tis); Sprite[] sprites = AssetDatabase.LoadAllAssetRepresentationsAtPath(ti.assetPath).Select(x => x as Sprite).Where(x => x != null).ToArray(); foreach (Sprite sprite in sprites) { //在这里设置每个图集的参数 Entry entry = new Entry(); entry.sprite = sprite; entry.settings.format = (TextureFormat)Enum.Parse(typeof(TextureFormat), ParseTextuerFormat(ti.spritePackingTag).ToString()); entry.settings.filterMode = FilterMode.Bilinear; entry.settings.colorSpace = ColorSpace.Linear; entry.settings.compressionQuality = (int)TextureCompressionQuality.Normal; entry.settings.filterMode = Enum.IsDefined(typeof(FilterMode), ti.filterMode) ? ti.filterMode : FilterMode.Bilinear; entry.settings.maxWidth = ParseTextureWidth(ti.spritePackingTag); entry.settings.maxHeight = ParseTextureHeight(ti.spritePackingTag); entry.atlasName = ParseAtlasName(ti.spritePackingTag); entry.packingMode = GetPackingMode(ti.spritePackingTag, tis.spriteMeshType); entries.Add(entry); } Resources.UnloadAsset(ti); } var atlasGroups = from e in entries group e by e.atlasName; foreach (var atlasGroup in atlasGroups) { int page = 0; // Then split those groups into smaller groups based on texture settings var settingsGroups = from t in atlasGroup group t by t.settings; foreach (var settingsGroup in settingsGroups) { string atlasName = atlasGroup.Key; if (settingsGroups.Count() > 1) atlasName += string.Format(" (Group {0})", page); job.AddAtlas(atlasName, settingsGroup.Key); foreach (Entry entry in settingsGroup) { job.AssignToAtlas(atlasName, entry.sprite, entry.packingMode, SpritePackingRotation.None); } ++page; } } }
void ConfigureSpriteAtlas(Texture2D texture, Rect[] uvs) { string path = AssetDatabase.GetAssetPath(texture); TextureImporter texImporter = AssetImporter.GetAtPath(path) as TextureImporter; TextureImporterSettings texImporterSettings = new TextureImporterSettings(); texImporter.textureType = TextureImporterType.Sprite; texImporter.spriteImportMode = SpriteImportMode.Multiple; // texImporterSettings.readable = true; SpriteMetaData[] spritesheetMeta = new SpriteMetaData[uvs.Length]; for(int i = 0; i < uvs.Length; i++) { SpriteMetaData currentMeta = new SpriteMetaData(); Rect currentRect = uvs[i]; currentRect.x *= texture.width; currentRect.width *= texture.width; currentRect.y *= texture.height; currentRect.height *= texture.height; currentMeta.rect = currentRect; currentMeta.name = textures[i].name; currentMeta.alignment = (int)SpriteAlignment.Center; currentMeta.pivot = new Vector2(currentRect.width / 2, currentRect.height / 2); spritesheetMeta[i] = currentMeta; } texImporter.spritesheet = spritesheetMeta; texImporter.spritePixelsToUnits = 1000f; texImporter.ReadTextureSettings(texImporterSettings); texImporter.SetTextureSettings(texImporterSettings); AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate); AssetDatabase.Refresh(); }
public void AddComponents(int layerIndex, GameObject imageObject, Sprite sprite, TextureImporterSettings settings) { var spr = imageObject.AddComponent<SpriteRenderer>(); spr.sprite = sprite; // If setting the sorting order is as simple as setting a sorting number, // do it here. Note that UiImgConstructor is more complex because of how // Unity UI uses the hierarchy position for sorting spr.sortingOrder = layerIndex; }
void RestoreTextureSettings(Texture2D image, TextureImporterSettings settings) { var imagePath = AssetDatabase.GetAssetPath(image); var imageImporter = (TextureImporter)TextureImporter.GetAtPath(imagePath); imageImporter.SetTextureSettings(settings); AssetDatabase.WriteImportSettingsIfDirty(imagePath); AssetDatabase.ImportAsset(imagePath, ImportAssetOptions.ForceSynchronousImport); AssetDatabase.Refresh(); }
public void AddComponents(int layerIndex, GameObject imageObject, Sprite sprite, TextureImporterSettings settings) { var uiImg = imageObject.AddComponent<Image>(); uiImg.sprite = sprite; uiImg.SetNativeSize(); uiImg.rectTransform.SetAsFirstSibling(); Vector2 sprPivot = PsdBuilder.GetPivot(settings); uiImg.rectTransform.pivot = sprPivot; }
private static SpriteMetaData GetMetaDataInSingleMode(string name, TextureImporter textureImporter) { SpriteMetaData result = default(SpriteMetaData); result.border = textureImporter.spriteBorder; result.name = name; result.pivot = textureImporter.spritePivot; result.rect = new Rect(0f, 0f, 1f, 1f); TextureImporterSettings textureImporterSettings = new TextureImporterSettings(); textureImporter.ReadTextureSettings(textureImporterSettings); result.alignment = textureImporterSettings.spriteAlignment; return result; }
private static SpriteMetaData GetMetaDataInSingleMode(string name, TextureImporter textureImporter) { SpriteMetaData spriteMetaData = new SpriteMetaData(); spriteMetaData.border = textureImporter.spriteBorder; spriteMetaData.name = name; spriteMetaData.pivot = textureImporter.spritePivot; spriteMetaData.rect = new Rect(0.0f, 0.0f, 1f, 1f); TextureImporterSettings dest = new TextureImporterSettings(); textureImporter.ReadTextureSettings(dest); spriteMetaData.alignment = dest.spriteAlignment; return spriteMetaData; }
void ConfigureForAtlas(string texturePath) { TextureImporter texImporter = AssetImporter.GetAtPath(texturePath) as TextureImporter; TextureImporterSettings texImporterSettings = new TextureImporterSettings(); texImporter.textureType = TextureImporterType.Sprite; texImporter.ReadTextureSettings(texImporterSettings); texImporterSettings.readable = true; texImporter.SetTextureSettings(texImporterSettings); AssetDatabase.ImportAsset(texturePath, ImportAssetOptions.ForceUpdate); AssetDatabase.Refresh(); }
TextureImporterSettings ChangeTextureSettings(Texture2D image, bool readable, TextureImporterFormat textureFormat) { var imagePath = AssetDatabase.GetAssetPath(image); var imageImporter = (TextureImporter)TextureImporter.GetAtPath(imagePath); var prevsetting = new TextureImporterSettings(); imageImporter.ReadTextureSettings(prevsetting); imageImporter.isReadable = readable; imageImporter.textureFormat = textureFormat; AssetDatabase.WriteImportSettingsIfDirty(imagePath); AssetDatabase.ImportAsset(imagePath, ImportAssetOptions.ForceSynchronousImport); AssetDatabase.Refresh(); return prevsetting; }
public void OnGroupAtlases(BuildTarget target, PackerJob job, int[] textureImporterInstanceIDs) { List<Entry> source = new List<Entry>(); foreach (int num in textureImporterInstanceIDs) { TextureFormat format; ColorSpace space; int num3; TextureImporter assetToUnload = EditorUtility.InstanceIDToObject(num) as TextureImporter; assetToUnload.ReadTextureImportInstructions(target, out format, out space, out num3); TextureImporterSettings dest = new TextureImporterSettings(); assetToUnload.ReadTextureSettings(dest); if (<>f__am$cache0 == null) {
/// <summary> /// <para>TODO.</para> /// </summary> /// <param name="platform"></param> public TextureImporterFormat GetAutomaticFormat(string platform) { TextureImporterSettings dest = new TextureImporterSettings(); this.ReadTextureSettings(dest); TextureImporterPlatformSettings platformTextureSettings = this.GetPlatformTextureSettings(platform); List<BuildPlayerWindow.BuildPlatform> validPlatforms = BuildPlayerWindow.GetValidPlatforms(); foreach (BuildPlayerWindow.BuildPlatform platform2 in validPlatforms) { if (platform2.name == platform) { return FormatFromTextureParameters(dest, platformTextureSettings, this.DoesSourceTextureHaveAlpha(), this.IsSourceTextureHDR(), platform2.DefaultTarget); } } return TextureImporterFormat.Automatic; }
static void ChangeTextureType_GuiFull() { Object[] textures = GetSelectedTextures(); Selection.objects = new Object[0]; foreach (Texture2D texture in textures) { string path = AssetDatabase.GetAssetPath(texture); //Debug.Log("path: " + path); TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter; textureImporter.textureType = TextureImporterType.GUI; textureImporter.npotScale = TextureImporterNPOTScale.None; TextureImporterSettings st = new TextureImporterSettings(); textureImporter.ReadTextureSettings(st); st.wrapMode = TextureWrapMode.Clamp; textureImporter.SetTextureSettings(st); AssetDatabase.ImportAsset(path); } }
private static void OnPostprocessTexture() { Object[] SelectedAsset = Selection.GetFiltered(typeof(Object), SelectionMode.DeepAssets); foreach (Object obj in SelectedAsset) { if (obj is Texture2D) { string path = AssetDatabase.GetAssetPath(obj); TextureImporter texImporter = GetTextureSettings(path); TextureImporterSettings tis = new TextureImporterSettings(); texImporter.ReadTextureSettings(tis); texImporter.SetTextureSettings(tis); AssetDatabase.ImportAsset(path); } } }
/// <summary> /// 把纹理放到编辑器中去 /// </summary> /// <param name="ps"></param> private static Texture2D AssembleTexture(ParticleSystem ps, Dictionary <int, object> resource) { Texture2D tex2D = null; Texture3D tex = resource[ps.TexId] as Texture3D; if (tex.IsATF) { } else { //实例化一个Texture2D,宽和高设置可以是任意的,因为当使用LoadImage方法会对Texture2D的宽和高会做相应的调整 //Texture2D tex2D = new Texture2D(1,1); //tex2D.LoadImage(tex.Data); var fileName = string.Empty; //if (!File.Exists(SceneFileCopy.GetAbsoluteTextureDir() + tex.Name)) { fileName = tex.Name; ps.UnityResourceParam.Texture2DPath = SceneFileCopy.GetRelativeTextureDir(ps.RootFileName) + fileName; } //else //{ // fileName = tex.Name.Substring(0, UnityEngine.Mathf.Max(0, tex.Name.Length - 4)) + "_" + Guid.NewGuid().ToString() + tex.Name.Substring(tex.Name.Length - 4, 4); // ps.UnityResourceParam.Texture2DPath = SceneFileCopy.GetRelativeTextureDir() + fileName; //} ps.UnityResourceParam.Texture2DPath = SceneFileCopy.GetRelativeTextureDir(ps.RootFileName) + fileName; SaveFile(SceneFileCopy.GetAbsoluteTextureDir(ps.RootFileName) + fileName, tex.Data); tex2D = UnityEditor.AssetDatabase.LoadAssetAtPath(ps.UnityResourceParam.Texture2DPath, typeof(Texture2D)) as Texture2D; UnityEditor.TextureImporter textureImporter = UnityEditor.AssetImporter.GetAtPath(ps.UnityResourceParam.Texture2DPath) as UnityEditor.TextureImporter; UnityEditor.TextureImporterSettings settings = new UnityEditor.TextureImporterSettings(); textureImporter.ReadTextureSettings(settings); settings.ApplyTextureType(UnityEditor.TextureImporterType.Default); textureImporter.SetTextureSettings(settings); textureImporter.textureType = UnityEditor.TextureImporterType.Default; //使用透明度 textureImporter.alphaIsTransparency = true; textureImporter.isReadable = true; textureImporter.filterMode = (UnityEngine.FilterMode)tex.FilterMode; textureImporter.wrapMode = (UnityEngine.TextureWrapMode)tex.WrapMode; textureImporter.mipmapEnabled = tex.MipMode > 0; UnityEditor.AssetDatabase.ImportAsset(ps.UnityResourceParam.Texture2DPath); } UnityEditor.AssetDatabase.Refresh(); return(tex2D); }
/// <summary> /// Sets the asset texture format. /// </summary> /// <returns><c>true</c>, if set format was set, <c>false</c> otherwise.</returns> /// <param name="path">Path.</param> /// <param name="format">Format.</param> public static bool AssetSetFormat(string path, TextureImporterFormat format) { if (string.IsNullOrEmpty(path)) return false; TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter; if (ti == null) return false; TextureImporterSettings settings = new TextureImporterSettings(); ti.ReadTextureSettings(settings); settings.textureFormat = format; ti.SetTextureSettings(settings); SPTools.DoAssetReimport(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport); return true; }
public void ConfigureForPacker(string path) { TextureImporter pImporter = AssetImporter.GetAtPath (path) as TextureImporter; pImporter.textureType = TextureImporterType.Advanced; TextureImporterSettings pSetting = new TextureImporterSettings (); pImporter.ReadTextureSettings (pSetting); //only 2D false pSetting.mipmapEnabled = false; pSetting.readable = true; pSetting.maxTextureSize = 4096; pSetting.textureFormat = TextureImporterFormat.ARGB32; pSetting.filterMode = FilterMode.Point; pSetting.wrapMode = TextureWrapMode.Clamp; pSetting.npotScale = TextureImporterNPOTScale.None; pImporter.SetTextureSettings (pSetting); AssetDatabase.ImportAsset (path,ImportAssetOptions.ForceUpdate); AssetDatabase.Refresh (); }
public void OnGroupAtlases(BuildTarget target, PackerJob job, int[] textureImporterInstanceIDs) { List<Entry> list = new List<Entry>(); string targetName = ""; if (target != BuildTarget.NoTarget) { targetName = BuildPipeline.GetBuildTargetName(target); } foreach (int num in textureImporterInstanceIDs) { TextureFormat format; ColorSpace space; int num3; TextureImporter ti = EditorUtility.InstanceIDToObject(num) as TextureImporter; ti.ReadTextureImportInstructions(target, out format, out space, out num3); TextureImporterSettings dest = new TextureImporterSettings(); ti.ReadTextureSettings(dest); bool flag = (targetName != "") && this.HasPlatformEnabledAlphaSplittingForCompression(targetName, ti); if (<>f__am$cache0 == null) {
static void ChangeTextureType_GuiFull() { IEnumerable<Object> textures = GetSelectedTextures(); Selection.objects = new Object[0]; foreach (var o in textures) { var texture = (Texture2D) o; var path = AssetDatabase.GetAssetPath(texture); //Debug.Log("path: " + path); var textureImporter = AssetImporter.GetAtPath(path) as TextureImporter; Debug.Assert(textureImporter != null, "textureImporter != null"); textureImporter.textureType = TextureImporterType.GUI; textureImporter.npotScale = TextureImporterNPOTScale.None; var st = new TextureImporterSettings(); textureImporter.ReadTextureSettings(st); st.wrapMode = TextureWrapMode.Clamp; textureImporter.SetTextureSettings(st); AssetDatabase.ImportAsset(path); } }
/// <summary> /// Sets the asset Read/Write enabled state. /// </summary> /// <returns><c>true</c>, if set read write enabled was asseted, <c>false</c> otherwise.</returns> /// <param name="path">Path.</param> /// <param name="enabled">If set to <c>true</c> enabled.</param> /// <param name="force">If set to <c>true</c> force.</param> public static bool AssetSetReadWriteEnabled(string path, bool enabled, bool force) { if (string.IsNullOrEmpty(path)) return false; TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter; if (ti == null) return false; TextureImporterSettings settings = new TextureImporterSettings(); ti.ReadTextureSettings(settings); if (force || settings.readable != enabled) { settings.readable = enabled; ti.SetTextureSettings(settings); SPTools.DoAssetReimport(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport); } return true; }
public void ApplySettings() { TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter; if(importer == null) { Debug.Log("Importer for asset at path: " + path + " is null."); return; } bool differentSettings = false; TextureImporterSettings settings = new TextureImporterSettings(); importer.ReadTextureSettings(settings); if(settings.mipmapEnabled != mipmaps) { settings.mipmapEnabled = mipmaps; differentSettings = true; } if(settings.maxTextureSize != maxSize) { settings.maxTextureSize = maxSize; differentSettings = true; } if(settings.textureFormat != format) { settings.textureFormat = format; differentSettings = true; } if(settings.npotScale != npotScale) { settings.npotScale = npotScale; differentSettings = true; } if(differentSettings) { importer.SetTextureSettings(settings); AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate); //Re-import the asset } }
// 步骤1 优化输入的纹理 private void ConfigureForTextureAtlas(string TexturePath) { // 1. 获取指定路径下的纹理 TextureImporter TexImport = AssetImporter.GetAtPath(TexturePath) as TextureImporter; TexImport.textureType = TextureImporterType.Advanced; // 2.修改此纹理的设置 TextureImporterSettings tiSettings = new TextureImporterSettings(); TexImport.ReadTextureSettings (tiSettings); tiSettings.mipmapEnabled = false; tiSettings.readable = true; tiSettings.maxTextureSize = 4096; tiSettings.textureFormat = TextureImporterFormat.ARGB32; tiSettings.filterMode = FilterMode.Point; tiSettings.wrapMode = TextureWrapMode.Clamp; tiSettings.npotScale = TextureImporterNPOTScale.None; TexImport.SetTextureSettings (tiSettings); // 3.重新把纹理导入到 unity 中 AssetDatabase.ImportAsset(TexturePath,ImportAssetOptions.ForceUpdate); AssetDatabase.Refresh (); }
public static void SetTexSettingsToAllSelected() { // get all the selected textures in the editor Object[] selectedTex = Selection.GetFiltered(typeof(Texture2D), SelectionMode.DeepAssets); // read the texture settings from the first texture in the selection list if (Selection.activeObject.GetType() != typeof(Texture2D)) { Debug.Log("Your first selection must be a texture asset!"); return; } string firstAssetPath = AssetDatabase.GetAssetPath(Selection.activeObject); Debug.Log("MultipleTexturesSetup: Applying texture settings from: " + firstAssetPath); TextureImporter texImporter = AssetImporter.GetAtPath(firstAssetPath) as TextureImporter; TextureImporterSettings texSettings = new TextureImporterSettings(); texImporter.ReadTextureSettings(texSettings); TextureImporterType texType = texImporter.textureType; // apply the texture settings to all the other selected textures Debug.Log("MultipleTexturesSetup: Applied texture settings to " + (selectedTex.Length - 1) + " textures:"); for(int i = 0; i < selectedTex.Length; i++) { string newAssetPath = AssetDatabase.GetAssetPath(selectedTex[i]); // avoid the first selected asset path (this is because the assets returned by Selection.GetFiltered are not in a known order if (firstAssetPath == newAssetPath) continue; texImporter = AssetImporter.GetAtPath(newAssetPath) as TextureImporter; texImporter.SetTextureSettings(texSettings); texImporter.textureType = texType; Debug.Log("MultipleTexturesSetup: " + newAssetPath); // re-import the texture with the new settings AssetDatabase.ImportAsset(newAssetPath, ImportAssetOptions.ForceSynchronousImport); } }
public static extern bool Equal(TextureImporterSettings a, TextureImporterSettings b);
internal static void setAtlasTextureSettings( string path, bool createMode ) { AssetDatabase.Refresh(); var importer = AssetImporter.GetAtPath( path ) as TextureImporter; if( importer == null ) { Debug.LogError( "Failed to obtain import settings for texture: " + path ); } importer.ClearPlatformTextureSettings( "iPhone" ); var settings = new TextureImporterSettings(); importer.ReadTextureSettings( settings ); settings.mipmapEnabled = false; settings.readable = false; settings.maxTextureSize = 4096; settings.textureFormat = TextureImporterFormat.AutomaticTruecolor; settings.wrapMode = TextureWrapMode.Clamp; settings.npotScale = TextureImporterNPOTScale.None; if( createMode ) { settings.filterMode = FilterMode.Bilinear; settings.alphaIsTransparency = true; settings.linearTexture = true; } importer.SetTextureSettings( settings ); AssetDatabase.ImportAsset( path, ImportAssetOptions.ForceUpdate ); }
public void CopyTo(TextureImporterSettings target) { Copy(this, target); }
//================================================================================ // 関数 //================================================================================ /// <summary> /// 指定された TextureImporter に設定を適用します /// </summary> public void Apply(TextureImporter importer) { var settings = new UnityEditor.TextureImporterSettings(); importer.ReadTextureSettings(settings); if (m_textureType.IsOverride) { settings.textureType = m_textureType.Value; } if (m_textureShape.IsOverride) { settings.textureShape = m_textureShape.Value; } if (m_spritePixelsPerUnit.IsOverride) { settings.spritePixelsPerUnit = m_spritePixelsPerUnit.Value; } if (m_spriteMeshType.IsOverride) { settings.spriteMeshType = m_spriteMeshType.Value; } if (m_spriteExtrude.IsOverride) { settings.spriteExtrude = m_spriteExtrude.Value; } if (m_spriteAlignment.IsOverride) { settings.spriteAlignment = ( int )m_spriteAlignment.Value; } if (m_spritePivot.IsOverride) { settings.spritePivot = m_spritePivot.Value; } if (m_spriteGenerateFallbackPhysicsShape.IsOverride) { settings.spriteGenerateFallbackPhysicsShape = m_spriteGenerateFallbackPhysicsShape.Value; } if (m_sRGBTexture.IsOverride) { settings.sRGBTexture = m_sRGBTexture.Value; } if (m_alphaSource.IsOverride) { settings.alphaSource = m_alphaSource.Value; } if (m_alphaIsTransparency.IsOverride) { settings.alphaIsTransparency = m_alphaIsTransparency.Value; } if (m_npotScale.IsOverride) { settings.npotScale = m_npotScale.Value; } if (m_readable.IsOverride) { settings.readable = m_readable.Value; } if (m_streamingMipmaps.IsOverride) { settings.streamingMipmaps = m_streamingMipmaps.Value; } if (m_streamingMipmapsPriority.IsOverride) { settings.streamingMipmapsPriority = m_streamingMipmapsPriority.Value; } if (m_mipmapEnabled.IsOverride) { settings.mipmapEnabled = m_mipmapEnabled.Value; } if (m_borderMipmap.IsOverride) { settings.borderMipmap = m_borderMipmap.Value; } if (m_mipmapFilter.IsOverride) { settings.mipmapFilter = m_mipmapFilter.Value; } if (m_mipMapsPreserveCoverage.IsOverride) { settings.mipMapsPreserveCoverage = m_mipMapsPreserveCoverage.Value; } if (m_alphaTestReferenceValue.IsOverride) { settings.alphaTestReferenceValue = m_alphaTestReferenceValue.Value; } if (m_fadeOut.IsOverride) { settings.fadeOut = m_fadeOut.Value; } if (m_mipmapFadeDistanceStart.IsOverride) { settings.mipmapFadeDistanceStart = m_mipmapFadeDistanceStart.Value; } if (m_mipmapFadeDistanceEnd.IsOverride) { settings.mipmapFadeDistanceEnd = m_mipmapFadeDistanceEnd.Value; } if (m_wrapMode.IsOverride) { settings.wrapMode = m_wrapMode.Value; } if (m_filterMode.IsOverride) { settings.filterMode = m_filterMode.Value; } if (m_aniso.IsOverride) { settings.aniso = m_aniso.Value; } if (m_defaultSettings != null) { var platformSettings = importer.GetPlatformTextureSettings("DefaultTexturePlatform"); m_defaultSettings.Apply(platformSettings); importer.SetPlatformTextureSettings(platformSettings); } if (m_standaloneSettings != null) { var platformSettings = importer.GetPlatformTextureSettings("Standalone"); m_standaloneSettings.Apply(platformSettings); importer.SetPlatformTextureSettings(platformSettings); } if (m_iPhoneSettings != null) { var platformSettings = importer.GetPlatformTextureSettings("iPhone"); platformSettings.overridden = true; m_iPhoneSettings.Apply(platformSettings); importer.SetPlatformTextureSettings(platformSettings); } if (m_androidSettings != null) { var platformSettings = importer.GetPlatformTextureSettings("Android"); m_androidSettings.Apply(platformSettings); importer.SetPlatformTextureSettings(platformSettings); } if (m_webGLSettings != null) { var platformSettings = importer.GetPlatformTextureSettings("WebGL"); m_webGLSettings.Apply(platformSettings); importer.SetPlatformTextureSettings(platformSettings); } importer.SetTextureSettings(settings); // TextureImporterSettings は Sprite Mode のパラメータを持っていないため // TextureImporter で設定する必要がある // また、Sprite Mode は SetTextureSettings の後に設定しないと反映されないので // SetTextureSettings の後に設定するようにしています if (m_spriteImportMode.IsOverride) { importer.spriteImportMode = m_spriteImportMode.Value; } }
private static extern void Copy([NotNull] TextureImporterSettings self, [Out][NotNull] TextureImporterSettings target);
// Read texture settings into [[TextureImporterSettings]] class. public void ReadTextureSettings(TextureImporterSettings dest) { settings.CopyTo(dest); }
internal static extern TextureImporterFormat FormatFromTextureParameters([NotNull] TextureImporterSettings settings, TextureImporterPlatformSettings platformSettings, bool doesTextureContainAlpha, bool sourceWasHDR, BuildTarget destinationPlatform);
bool MakeTextureReadable(Texture tex) { string path = AssetDatabase.GetAssetPath(tex.GetInstanceID()); if (string.IsNullOrEmpty(path)) return false; TextureImporter ti = AssetImporter.GetAtPath(path) as TextureImporter; if (ti == null) return false; TextureImporterSettings settings = new TextureImporterSettings(); ti.ReadTextureSettings(settings); if (!settings.readable) { settings.readable = true; ti.SetTextureSettings(settings); AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport); } return true; }
// Set texture importers settings from [[TextureImporterSettings]] class. public void SetTextureSettings(TextureImporterSettings src) { settings = src; }
internal static extern TextureImporterFormat SimpleToFullTextureFormat2(TextureImporterFormat simpleFormat, TextureImporterType tType, TextureImporterSettings settings, bool doesTextureContainAlpha, bool sourceWasHDR, BuildTarget destinationPlatform);
public extern void ReadTextureSettings(TextureImporterSettings dest);
public extern void CopyTo(TextureImporterSettings target);
private static extern void Internal_ApplyTextureType([Out][NotNull] TextureImporterSettings self, TextureImporterType type);
private static extern void Internal_ApplyTextureType(TextureImporterSettings s, TextureImporterType type, bool applyAll);
public extern void SetTextureSettings(TextureImporterSettings src);
public static void ApplySpriteSettings(Texture2D texture, SpriteSettings prefs, SpriteFileSettings fileSettings) { if (prefs == null) return; string path = AssetDatabase.GetAssetPath (texture); var importer = AssetImporter.GetAtPath(path) as TextureImporter; // When we have text file data SpriteSlicingOptions slicingOptions = fileSettings.SlicingOptions; if (slicingOptions.ImportMode == SpriteImportMode.Multiple) { // Clamp cellSize to texture width and height slicingOptions.CellSize.x = Mathf.Min (texture.width, slicingOptions.CellSize.x); slicingOptions.CellSize.y = Mathf.Min (texture.height, slicingOptions.CellSize.y); SpriteMetaData[] spriteSheet; spriteSheet = SpriteSlicer.CreateSpriteSheetForTexture (AssetDatabase.LoadAssetAtPath(path, typeof(Texture2D)) as Texture2D, slicingOptions); // If we don't do this it won't update the new sprite meta data importer.spriteImportMode = SpriteImportMode.Single; importer.spriteImportMode = SpriteImportMode.Multiple; importer.spritesheet = spriteSheet; } else if (slicingOptions.ImportMode == SpriteImportMode.Single) { importer.spriteImportMode = SpriteImportMode.Single; } else if (slicingOptions.ImportMode == SpriteImportMode.None) { // Do nothing for None mode for now. } else { throw new System.NotSupportedException ("Encountered unsupported SpriteImportMode:" + slicingOptions.ImportMode); } TextureImporterSettings settings = new TextureImporterSettings(); importer.ReadTextureSettings(settings); importer.textureType = TextureImporterType.Advanced; settings.filterMode = prefs.FilterMode; settings.wrapMode = prefs.WrapMode; settings.mipmapEnabled = prefs.GenerateMipMaps; settings.textureFormat = prefs.TextureFormat; settings.maxTextureSize = prefs.MaxSize; settings.spritePixelsPerUnit = prefs.PixelsPerUnit; settings.spriteExtrude = (uint)Mathf.Clamp(prefs.ExtrudeEdges, 0, 32); settings.spriteMeshType = prefs.SpriteMeshType; // Settings also store Sprite Alignment for Single spritemode settings.spriteAlignment = (int)slicingOptions.Pivot; if (slicingOptions.Pivot == SpriteAlignment.Custom) { settings.spritePivot = slicingOptions.CustomPivot; } importer.spritePackingTag = fileSettings.PackingTag; importer.SetTextureSettings(settings); #if UNITY_5_0 importer.SaveAndReimport(); #else AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate); #endif EditorUtility.SetDirty(texture); WriteSpriteFileSettings (path, prefs.SpritesheetDataFile, texture.name + ".png", fileSettings); }
public void ApplyTextureType(TextureImporterType type, bool applyAll) { TextureImporterSettings.Internal_ApplyTextureType(this, type, applyAll); }