public static (int Width, int Height, string Extension) Find(TextureSettings settings, string texture) { (Stream? stream, string?path) = FindStream(settings, texture); if (stream is null) { return(0, 0, path); } try { using var image = Image.Load(stream); return(image.Width, image.Height, path); } catch { try { using var tga = Pfim.Pfim.FromStream(stream); return(tga.Width, tga.Height, path); } catch { return(0, 0, path); } } }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion)); node.Add(WidthName, Width); node.Add(HeightName, Height); node.Add(AntiAliasingName, AntiAliasing); if (IsReadMipCount(container.ExportVersion)) { node.Add(MipCountName, MipCount); } node.Add(DepthFormatName, DepthFormat); node.Add(ColorFormatName, (int)ColorFormat); node.Add(MipMapName, MipMap); node.Add(GenerateMipsName, GenerateMips); node.Add(SRGBName, SRGB); node.Add(UseDynamicScaleName, UseDynamicScale); node.Add(BindMSName, BindMS); if (IsReadEnableCompatibleFormat(container.ExportVersion)) { node.Add(EnableCompatibleFormatName, GetEnableCompatibleFormat(container.Version)); } node.Add(TextureSettingsName, TextureSettings.ExportYAML(container)); node.Add(DimensionName, Dimension); node.Add(VolumeDepthName, VolumeDepth); return(node); }
protected override void WriteObject(AssetsWriter writer) { base.WriteBase(writer); writer.Write(Name); writer.Write(ForcedFallbackFormat); writer.Write(DownscaleFallback); writer.AlignTo(4); writer.Write(Width); writer.Write(Height); writer.Write(CompleteImageSize); writer.Write((int)TextureFormat); writer.Write(MipCount); writer.Write(IsReadable); writer.Write(StreamingMipmaps); writer.AlignTo(4); writer.Write(StreamingMipmapsPriority); writer.Write(ImageCount); writer.Write(TextureDimension); TextureSettings.Write(writer); writer.Write(LightmapFormat); writer.Write(ColorSpace); writer.Write(ImageData.Length); writer.Write(ImageData); writer.AlignTo(4); StreamData.Write(writer); }
protected sealed override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); if (HasColorSpace(container.ExportVersion)) { node.Add(ColorSpaceName, (int)ColorSpace); } node.Add(FormatName, (int)Format); node.Add(WidthName, Width); node.Add(HeightName, Height); node.Add(DepthName, Depth); node.Add(MipCountName, MipCount); node.Add(DataSizeName, DataSize); node.Add(TextureSettingsName, TextureSettings.ExportYAML(container)); node.Add(IsReadableName, IsReadable); IReadOnlyList <byte> imageData = GetImageData(container.Version); node.Add(ImageDataName, imageData.Count); node.Add(TypelessdataName, imageData.ExportYAML()); StreamingInfo streamData = new StreamingInfo(true); node.Add(StreamDataName, streamData.ExportYAML(container)); return(node); }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion)); node.Add(WidthName, Width); node.Add(HeightName, Height); node.Add(CompleteImageSizeName, CompleteImageSize); node.Add(TextureFormatName, (int)TextureFormat); node.Add(MipCountName, MipCount); node.Add(IsReadableName, IsReadable); if (IsReadStreamingMipmaps(container.ExportVersion)) { node.Add(StreamingMipmapsName, StreamingMipmaps); } if (IsReadStreamingMipmapsPriority(container.ExportVersion)) { node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority); } node.Add(AlphaIsTransparencyName, GetAlphaIsTransparency(container.Version, container.Flags)); node.Add(ImageCountName, ImageCount); node.Add(TextureDimensionName, (int)TextureDimension); node.Add(TextureSettingsName, TextureSettings.ExportYAML(container)); node.Add(LightmapFormatName, (int)LightmapFormat); node.Add(ColorSpaceName, (int)ColorSpace); IReadOnlyList <byte> imageData = GetExportImageData(); node.Add(ImageDataName, imageData.Count); node.Add(TypelessdataName, imageData.ExportYAML()); StreamingInfo streamData = new StreamingInfo(true); node.Add(StreamDataName, streamData.ExportYAML(container)); return(node); }
private LaTeXTextureDownloader(string[, , ] laTeX, TextureSettings?settings) { this.laTeXTensor = laTeX; this.settings = settings ?? new TextureSettings() { size = Size.normal }; }
public Texture2D(AssetInfo assetInfo) : base(assetInfo) { TextureSettings = new TextureSettings(assetInfo.AssetFile); if (IsReadStreamData) { StreamData = new StreamingInfo(); } }
public override void Read(AssetStream stream) { base.Read(stream); Width = stream.ReadInt32(); Height = stream.ReadInt32(); CompleteImageSize = stream.ReadInt32(); TextureFormat = (TextureFormat)stream.ReadInt32(); if (IsBoolMinMap(stream.Version)) { MipMap = stream.ReadBoolean(); if (MipMap) { int maxSide = Math.Max(Width, Height); MipCount = Convert.ToInt32(Math.Log(maxSide) / Math.Log(2)); } else { MipCount = 1; } } else { MipCount = stream.ReadInt32(); } if (IsReadIsReadable(stream.Version)) { IsReadable = stream.ReadBoolean(); } if (IsReadReadAllowed(stream.Version)) { ReadAllowed = stream.ReadBoolean(); } stream.AlignStream(AlignType.Align4); ImageCount = stream.ReadInt32(); TextureDimension = stream.ReadInt32(); TextureSettings.Read(stream); if (IsReadLightmapFormat(stream.Version)) { LightmapFormat = stream.ReadInt32(); } if (IsReadColorSpace(stream.Version)) { ColorSpace = (ColorSpace)stream.ReadInt32(); } m_imageData = stream.ReadByteArray(); stream.AlignStream(AlignType.Align4); if (IsReadStreamData(stream.Version)) { StreamData.Read(stream); } }
private bool IsOptimized() { foreach (var oTarget in serializedObject.targetObjects) { var myTarget = oTarget as BbSprite; Debug.Assert(myTarget != null, "myTarget != null"); if (!TextureSettings.IsAtlasOptimalForBbSprite(myTarget.Atlas)) { return(false); } } return(true); }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.Add(TextureSettingsName, TextureSettings.ExportYAML(container)); node.Add(IsReadableName, IsReadable); if (HasSRGBTexture(container.ExportVersion)) { node.Add(SRGBTextureName, SRGBTexture); } if (HasStreamingMipmaps(container.ExportVersion)) { node.Add(StreamingMipmapsName, StreamingMipmaps); node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority); } PostExportYAML(container, node); return(node); }
private void Optimize() { if (EditorUtility.DisplayDialog( "Turn off blurring", "This will alter the current texture's settings to remove " + "blur/antialiasing/etc.\nThe texture's pixels will be sharp and " + "unobscured.\n\nWarning: These changes must be undone manually.\n" + "They include:\n" + TextureSettings.BbSpriteOptimalSettingsList, "OK", "Cancel")) { foreach (var oTarget in serializedObject.targetObjects) { var myTarget = oTarget as BbSprite; Debug.Assert(myTarget != null, "myTarget != null"); TextureSettings.SetAtlasAsOptimalForBbSprite(myTarget.Atlas); myTarget.Update(); } } }
protected override YAMLMappingNode ExportYAMLRoot(IAssetsExporter exporter) { YAMLMappingNode node = base.ExportYAMLRoot(exporter); node.Add("m_Width", Width); node.Add("m_Height", Height); node.Add("m_AntiAliasing", AntiAliasing); node.Add("m_DepthFormat", DepthFormat); node.Add("m_ColorFormat", (int)ColorFormat); node.Add("m_MipMap", MipMap); node.Add("m_GenerateMips", GenerateMips); node.Add("m_SRGB", SRGB); node.Add("m_UseDynamicScale", UseDynamicScale); node.Add("m_BindMS", BindMS); node.Add("m_TextureSettings", TextureSettings.ExportYAML(exporter)); node.Add("m_Dimension", Dimension); node.Add("m_VolumeDepth", VolumeDepth); return(node); }
public override void Read(AssetReader reader) { base.Read(reader); TextureSettings.Read(reader); IsReadable = reader.ReadBoolean(); if (HasSRGBTexture(reader.Version)) { SRGBTexture = reader.ReadBoolean(); } if (HasStreamingMipmaps(reader.Version)) { StreamingMipmaps = reader.ReadBoolean(); reader.AlignStream(); StreamingMipmapsPriority = reader.ReadInt32(); } reader.AlignStream(); PostRead(reader); }
public override void Write(AssetWriter writer) { base.Write(writer); TextureSettings.Write(writer); writer.Write(IsReadable); if (HasSRGBTexture(writer.Version)) { writer.Write(SRGBTexture); } if (HasStreamingMipmaps(writer.Version)) { writer.Write(StreamingMipmaps); writer.AlignStream(); writer.Write(StreamingMipmapsPriority); } writer.AlignStream(); PostWrite(writer); }
public YAMLNode ExportYAML(IExportContainer container) { int version = TextureSettings.GetSerializedVersion(container.Version); YAMLMappingNode node = new YAMLMappingNode(); node.AddSerializedVersion(version); node.Add("filterMode", (int)m_textureSettings.FilterMode); node.Add("aniso", m_textureSettings.Aniso); node.Add("mipBias", m_textureSettings.MipBias); if (version >= 2) { node.Add("wrapU", (int)m_textureSettings.WrapU); node.Add("wrapV", (int)m_textureSettings.WrapV); node.Add("wrapW", (int)m_textureSettings.WrapW); } else { node.Add("wrapMode", (int)m_textureSettings.WrapU); } return(node); }
private void GUI2DArray() { oldTexList = TexList; GUILayout.Label("Texture List"); TexList = EditorGUILayout.ObjectField("", TexList, typeof(TextureList), false) as TextureList; /* Copy the settings over from the first texture when a new texture list is put in the object field **/ if (oldTexList != TexList && TexList != null && TexList.TexArray.Length > 0 && TexList.TexArray[0] != null) { filterMode = TexList.TexArray[0].filterMode; anisoLevel = TexList.TexArray[0].anisoLevel; wrapModeU = TexList.TexArray[0].wrapModeU; wrapModeV = TexList.TexArray[0].wrapModeV; if (wrapModeU == wrapModeV) { wrapMode = (int)wrapModeU; } else { wrapMode = 4; } } /* Do we want mip maps? if so, copy them from the source textures **/ copyMips = EditorGUILayout.Toggle("Copy Mip Maps", copyMips); if (copyMips) { mipMapBias = EditorGUILayout.FloatField(" Mip Map Bias", mipMapBias); } filterMode = (FilterMode)EditorGUILayout.Popup("Filter Mode", (int)filterMode, filters); /* Set the wrap mode to the same value on both axes unless wrapMode is 4 (Per Axis), then show separate options**/ wrapMode = EditorGUILayout.Popup("Wrap Mode", wrapMode, wraps); if (wrapMode == 4) { wrapModeU = (TextureWrapMode)EditorGUILayout.Popup(" U Axis", (int)wrapModeU, wrapsAxis); wrapModeV = (TextureWrapMode)EditorGUILayout.Popup(" V Axis", (int)wrapModeV, wrapsAxis); } else { wrapModeU = (TextureWrapMode)wrapMode; wrapModeV = (TextureWrapMode)wrapMode; } anisoLevel = EditorGUILayout.IntSlider("Aniso Level", anisoLevel, 0, 16); /* Show the user the settings that are going to be copied over from the source textures directly **/ showProperties = EditorGUILayout.Foldout(showProperties, "Inherited Properties", true); if (showProperties && TexList != null) { printProperties(TexList.TexArray); } GUILayout.FlexibleSpace(); EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (GUILayout.Button("Create Array", GUILayout.Width(100), GUILayout.Height(30))) { TextureSettings settings = new TextureSettings(); settings.filterMode = filterMode; settings.copyMips = copyMips; settings.mipMapBias = mipMapBias; settings.wrapModeU = wrapModeU; settings.wrapModeV = wrapModeV; settings.anisoLevel = anisoLevel; CopyListIntoArray(TexList, settings); } }
public override void Read(AssetStream stream) { base.Read(stream); if (IsReadIsPowerOfTwo(stream.Version)) { if (IsReadIsPowerOfTwoFirst(stream.Version)) { IsPowerOfTwo = stream.ReadBoolean(); } } Width = stream.ReadInt32(); Height = stream.ReadInt32(); if (IsReadAntiAliasing(stream.Version)) { AntiAliasing = stream.ReadInt32(); } DepthFormat = stream.ReadInt32(); if (IsReadColorFormat(stream.Version)) { ColorFormat = (RenderTextureFormat)stream.ReadInt32(); } if (IsReadIsPowerOfTwo(stream.Version)) { if (!IsReadIsPowerOfTwoFirst(stream.Version)) { IsPowerOfTwo = stream.ReadBoolean(); } } if (IsReadIsCubemap(stream.Version)) { IsCubemap = stream.ReadBoolean(); } if (IsReadMipMap(stream.Version)) { MipMap = stream.ReadBoolean(); } if (IsReadGenerateMips(stream.Version)) { GenerateMips = stream.ReadBoolean(); } if (IsReadSRGB(stream.Version)) { SRGB = stream.ReadBoolean(); } if (IsReadUseDynamicScale(stream.Version)) { UseDynamicScale = stream.ReadBoolean(); BindMS = stream.ReadBoolean(); } if (IsAlign(stream.Version)) { stream.AlignStream(AlignType.Align4); } TextureSettings.Read(stream); if (IsReadDimension(stream.Version)) { Dimension = stream.ReadInt32(); VolumeDepth = stream.ReadInt32(); } }
/// <summary> /// Finds the specified texture with the given search settings. /// </summary> /// <param name="settings">The settings for the texture search.</param> /// <param name="texture">The texture name.</param> /// <returns>The data stream of the texture.</returns> private static (Stream?Stream, string Extension) FindStream(TextureSettings settings, string texture) => FindInDirectory(settings, texture.Split('/', '\\'), new List <string>());
public override void Read(AssetReader reader) { base.Read(reader); if (HasColorSpace(reader.Version)) { if (IsColorSpaceFirst(reader.Version)) { ColorSpace = (ColorSpace)reader.ReadInt32(); } } if (IsFormatFirst(reader.Version)) { Format = (TextureFormat)reader.ReadInt32(); } Width = reader.ReadInt32(); Height = reader.ReadInt32(); if (HasDepth(reader.Version)) { Depth = reader.ReadInt32(); } if (IsDataSizeFirst(reader.Version)) { DataSize = reader.ReadInt32(); } if (!IsFormatFirst(reader.Version)) { Format = (TextureFormat)reader.ReadInt32(); } if (IsBoolMinMap(reader.Version)) { bool mipMap = reader.ReadBoolean(); if (mipMap) { int maxSide = Math.Max(Width, Height); MipCount = System.Convert.ToInt32(Math.Log(maxSide) / Math.Log(2)); } else { MipCount = 1; } } else { MipCount = reader.ReadInt32(); } if (!IsDataSizeFirst(reader.Version)) { DataSize = reader.ReadInt32(); } if (IsReadableFirst(reader.Version)) { IsReadable = reader.ReadBoolean(); } if (HasReadAllowed(reader.Version)) { ReadAllowed = reader.ReadBoolean(); } reader.AlignStream(); if (HasImageCount(reader.Version)) { ImageCount = reader.ReadInt32(); TextureDimension = (TextureDimension)reader.ReadInt32(); } TextureSettings.Read(reader); if (IsReadableSecond(reader.Version)) { IsReadable = reader.ReadBoolean(); reader.AlignStream(); } if (HasLightmapFormat(reader.Version)) { LightmapFormat = (TextureUsageMode)reader.ReadInt32(); } if (HasColorSpace(reader.Version)) { if (!IsColorSpaceFirst(reader.Version)) { ColorSpace = (ColorSpace)reader.ReadInt32(); } } m_imageData = reader.ReadByteArray(); reader.AlignStream(); if (HasStreamData(reader.Version)) { StreamData.Read(reader); } }
public override void Read(AssetReader reader) { base.Read(reader); #if UNIVERSAL bool hasAlphaIsTransparency = HasAlphaIsTransparency(reader.Version, reader.Flags); int alphaIsTransparencyOrder = GetAlphaIsTransparencyOrder(reader.Version); if (hasAlphaIsTransparency && alphaIsTransparencyOrder == 0) { AlphaIsTransparency = reader.ReadBoolean(); reader.AlignStream(); } #endif Width = reader.ReadInt32(); Height = reader.ReadInt32(); CompleteImageSize = reader.ReadInt32(); TextureFormat = (TextureFormat)reader.ReadInt32(); if (IsBoolMinMap(reader.Version)) { bool mipMap = reader.ReadBoolean(); if (mipMap) { int maxSide = Math.Max(Width, Height); MipCount = System.Convert.ToInt32(Math.Log(maxSide) / Math.Log(2)); } else { MipCount = 1; } } else { MipCount = reader.ReadInt32(); } if (HasReadable(reader.Version)) { IsReadable = reader.ReadBoolean(); } if (HasIgnoreMasterTextureLimit(reader.Version)) { IgnoreMasterTextureLimit = reader.ReadBoolean(); } if (HasIsPreProcessed(reader.Version)) { IsPreProcessed = reader.ReadBoolean(); } if (HasReadAllowed(reader.Version)) { ReadAllowed = reader.ReadBoolean(); } if (HasStreamingMipmaps(reader.Version)) { StreamingMipmaps = reader.ReadBoolean(); } #if UNIVERSAL if (hasAlphaIsTransparency && alphaIsTransparencyOrder == 1) { AlphaIsTransparency = reader.ReadBoolean(); } #endif reader.AlignStream(); if (HasStreamingMipmapsPriority(reader.Version)) { StreamingMipmapsPriority = reader.ReadInt32(); #if UNIVERSAL if (hasAlphaIsTransparency && alphaIsTransparencyOrder == 2) { AlphaIsTransparency = reader.ReadBoolean(); } #endif reader.AlignStream(); } ImageCount = reader.ReadInt32(); TextureDimension = (TextureDimension)reader.ReadInt32(); TextureSettings.Read(reader); if (HasLightmapFormat(reader.Version)) { LightmapFormat = (TextureUsageMode)reader.ReadInt32(); } if (HasColorSpace(reader.Version)) { ColorSpace = (ColorSpace)reader.ReadInt32(); } m_imageData = reader.ReadByteArray(); reader.AlignStream(); if (HasStreamData(reader.Version)) { StreamData.Read(reader); } }
public override void Read(AssetReader reader) { base.Read(reader); if (IsReadIsPowerOfTwo(reader.Version)) { if (IsReadIsPowerOfTwoFirst(reader.Version)) { IsPowerOfTwo = reader.ReadBoolean(); } } Width = reader.ReadInt32(); Height = reader.ReadInt32(); if (IsReadAntiAliasing(reader.Version)) { AntiAliasing = reader.ReadInt32(); } DepthFormat = reader.ReadInt32(); if (IsReadColorFormat(reader.Version)) { ColorFormat = (RenderTextureFormat)reader.ReadInt32(); } if (IsReadIsPowerOfTwo(reader.Version)) { if (!IsReadIsPowerOfTwoFirst(reader.Version)) { IsPowerOfTwo = reader.ReadBoolean(); } } if (IsReadIsCubemap(reader.Version)) { IsCubemap = reader.ReadBoolean(); } if (IsReadMipMap(reader.Version)) { MipMap = reader.ReadBoolean(); } if (IsReadGenerateMips(reader.Version)) { GenerateMips = reader.ReadBoolean(); } if (IsReadSRGB(reader.Version)) { SRGB = reader.ReadBoolean(); } if (IsReadUseDynamicScale(reader.Version)) { UseDynamicScale = reader.ReadBoolean(); BindMS = reader.ReadBoolean(); } if (IsAlign(reader.Version)) { reader.AlignStream(AlignType.Align4); } TextureSettings.Read(reader); if (IsReadDimension(reader.Version)) { Dimension = reader.ReadInt32(); VolumeDepth = reader.ReadInt32(); } }
private static IEnumerable <TestCaseData> GenerateSpriteTestCases() { var buffer = new Color32[64 * 64]; var settings = new TextureSettings(); var alphaSettingsFromInput = new TextureAlphaSettings(); alphaSettingsFromInput.alphaSource = TextureImporterAlphaSource.FromInput; var alphaSettingsFromGrayScale = new TextureAlphaSettings(); alphaSettingsFromGrayScale.alphaSource = TextureImporterAlphaSource.FromGrayScale; var alphaSettingsNone = new TextureAlphaSettings(); alphaSettingsNone.alphaSource = TextureImporterAlphaSource.None; var platformSettings = new TextureImporterPlatformSettings(); var platformSettingsOverride = new TextureImporterPlatformSettings(); platformSettingsOverride.overridden = true; platformSettingsOverride.maxTextureSize = 32; var spriteSettings = new TextureSpriteSettings(); var spriteSettingsWithSprites = new TextureSpriteSettings(); spriteSettingsWithSprites.spriteSheetData = new SpriteImportData[] { new SpriteImportData() { name = "Sprite1", rect = new Rect(0, 0, 32, 32), spriteID = GUID.Generate().ToString() }, new SpriteImportData() { name = "Sprite2", rect = new Rect(32, 32, 32, 32), spriteID = GUID.Generate().ToString() }, new SpriteImportData() { name = "Sprite3", rect = new Rect(0, 32, 32, 32), spriteID = GUID.Generate().ToString() }, }; { GenerateSpriteTestCase testCase = new GenerateSpriteTestCase { settings = settings, platformSettings = platformSettings, spriteSettings = spriteSettings, bufferWidth = 64, bufferHeight = 64, buffer = buffer, testName = "GenerateSpriteWithNoSpriteData" }; yield return(new TestCaseData(testCase)); testCase.spriteSettings = spriteSettingsWithSprites; testCase.testName = "GenerateSpriteWithSpriteData"; yield return(new TestCaseData(testCase)); } { GenerateSpriteTestCase testCase = new GenerateSpriteTestCase { settings = settings, platformSettings = platformSettings, spriteSettings = spriteSettings, bufferWidth = 64, bufferHeight = 64, buffer = buffer, testName = "GenerateSpriteWithNoSpriteData_AlphaNone", alphaSettings = alphaSettingsNone }; yield return(new TestCaseData(testCase)); testCase.testName = "GenerateSpriteWithSpriteData_AlphaNone"; testCase.spriteSettings = spriteSettingsWithSprites; yield return(new TestCaseData(testCase)); } { GenerateSpriteTestCase testCase = new GenerateSpriteTestCase { settings = settings, platformSettings = platformSettings, spriteSettings = spriteSettings, bufferWidth = 64, bufferHeight = 64, buffer = buffer, testName = "GenerateSpriteWithNoSpriteData_AlphaGrayScale", alphaSettings = alphaSettingsFromGrayScale }; yield return(new TestCaseData(testCase)); testCase.testName = "GenerateSpriteWithSpriteData_AlphaGrayScale"; testCase.spriteSettings = spriteSettingsWithSprites; yield return(new TestCaseData(testCase)); } { GenerateSpriteTestCase testCase = new GenerateSpriteTestCase { settings = settings, platformSettings = platformSettings, spriteSettings = spriteSettings, bufferWidth = 64, bufferHeight = 64, buffer = buffer, testName = "GenerateSpriteWithNoSpriteData_AlphaFromInput", alphaSettings = alphaSettingsFromInput }; yield return(new TestCaseData(testCase)); testCase.testName = "GenerateSpriteWithSpriteData_AlphaFromInput"; testCase.spriteSettings = spriteSettingsWithSprites; yield return(new TestCaseData(testCase)); } { GenerateSpriteTestCase testCase = new GenerateSpriteTestCase { settings = settings, platformSettings = platformSettingsOverride, spriteSettings = spriteSettings, bufferWidth = 64, bufferHeight = 64, buffer = buffer, testName = "GenerateSpriteWithNoSpriteData_WithPlatformOverride", alphaSettings = alphaSettingsFromInput }; yield return(new TestCaseData(testCase)); testCase.testName = "GenerateSpriteWithSpriteData_WithPlatformOverride"; testCase.spriteSettings = spriteSettingsWithSprites; yield return(new TestCaseData(testCase)); } }
// TODO: We should rather put the texture settings in LightLoop, but how do we serialize it ? public virtual void Build(TextureSettings textureSettings) { }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion)); YAMLMappingNode mipmap = new YAMLMappingNode(); mipmap.Add(MipMapModeName, (int)MipMapMode); mipmap.Add(EnableMipMapName, EnableMipMap); if (HasSRGBTexture(container.ExportVersion)) { mipmap.Add(SRGBTextureName, SRGBTexture); } if (HasLinearTexture(container.ExportVersion)) { mipmap.Add(LinearTextureName, LinearTexture); } if (HasCorrectGamma(container.ExportVersion)) { mipmap.Add(CorrectGammaName, CorrectGamma); } mipmap.Add(FadeOutName, FadeOut); mipmap.Add(BorderMipMapName, BorderMipMap); if (HasMipMapsPreserveCoverage(container.ExportVersion)) { mipmap.Add(MipMapsPreserveCoverageName, MipMapsPreserveCoverage); mipmap.Add(AlphaTestReferenceValueName, AlphaTestReferenceValue); } mipmap.Add(MipMapFadeDistanceStartName, MipMapFadeDistanceStart); mipmap.Add(MipMapFadeDistanceEndName, MipMapFadeDistanceEnd); node.Add(MipmapsName, mipmap); YAMLMappingNode bumpmap = new YAMLMappingNode(); bumpmap.Add(ConvertToNormalMapName, ConvertToNormalMap); if (HasExternalNormalMap(container.ExportVersion)) { bumpmap.Add(ExternalNormalMapName, ExternalNormalMap); } bumpmap.Add(HeightScaleName, HeightScale); bumpmap.Add(NormalMapFilterName, (int)NormalMapFilter); node.Add(BumpmapName, bumpmap); if (HasIsReadable(container.ExportVersion)) { node.Add(IsReadableName, IsReadable); } if (HasStreamingMipmaps(container.ExportVersion)) { node.Add(StreamingMipmapsName, StreamingMipmaps); node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority); } node.Add(GrayScaleToAlphaName, GrayScaleToAlpha); node.Add(GenerateCubemapName, (int)GenerateCubemap); if (HasCubemapConvolution(container.ExportVersion)) { node.Add(CubemapConvolutionName, CubemapConvolution); } if (HasCubemapConvolutionSteps(container.ExportVersion)) { node.Add(CubemapConvolutionStepsName, CubemapConvolutionSteps); node.Add(CubemapConvolutionExponentName, CubemapConvolutionExponent); } if (HasSeamlessCubemap(container.ExportVersion)) { node.Add(SeamlessCubemapName, SeamlessCubemap); } node.Add(TextureFormatName, (int)TextureFormat); if (HasRecommendedTextureFormat(container.ExportVersion) && RecommendedTextureFormatFirst(container.ExportVersion)) { node.Add(RecommendedTextureFormatName, RecommendedTextureFormat); } node.Add(MaxTextureSizeName, MaxTextureSize); node.Add(TextureSettingsName, TextureSettings.ExportYAML(container)); node.Add(NPOTScaleName, (int)NPOTScale); if (HasLightmap(container.ExportVersion)) { node.Add(LightmapName, Lightmap); } if (HasRGBM(container.ExportVersion)) { node.Add(RGBMName, RGBM); } if (HasCompressionQuality(container.ExportVersion)) { node.Add(CompressionQualityName, CompressionQuality); } if (HasAllowsAlphaSplitting(container.ExportVersion)) { node.Add(AllowsAlphaSplittingName, AllowsAlphaSplitting); } if (HasSprite(container.ExportVersion)) { node.Add(SpriteModeName, (int)SpriteMode); node.Add(SpriteExtrudeName, SpriteExtrude); node.Add(SpriteMeshTypeName, (int)SpriteMeshType); node.Add(AlignmentName, (int)Alignment); node.Add(SpritePivotName, SpritePivot.ExportYAML(container)); } if (HasSprite(container.ExportVersion) && SpritePixelsToUnitsFirst(container.ExportVersion)) { node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits); } if (HasSpriteBorder(container.ExportVersion)) { node.Add(SpriteBorderName, SpriteBorder.ExportYAML(container)); } if (HasSprite(container.ExportVersion) && !SpritePixelsToUnitsFirst(container.ExportVersion)) { node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits); } if (HasSpriteGenerateFallbackPhysicsShape(container.ExportVersion)) { node.Add(SpriteGenerateFallbackPhysicsShapeName, SpriteGenerateFallbackPhysicsShape); } if (HasAlphaUsage(container.ExportVersion)) { node.Add(AlphaUsageName, (int)AlphaUsage); } if (HasAlphaIsTransparency(container.ExportVersion)) { node.Add(AlphaIsTransparencyName, AlphaIsTransparency); } if (HasSpriteTessellationDetail(container.ExportVersion)) { node.Add(SpriteTessellationDetailName, SpriteTessellationDetail); } if (HasTextureType(container.ExportVersion)) { node.Add(TextureTypeName, (int)TextureType); } if (HasRecommendedTextureFormat(container.ExportVersion) && !RecommendedTextureFormatFirst(container.ExportVersion)) { node.Add(RecommendedTextureFormatName, RecommendedTextureFormat); } if (HasSourceTextureInformation(container.ExportVersion)) { node.Add(SourceTextureInformationName, SourceTextureInformation.ExportYAML(container)); } if (HasTextureShape(container.ExportVersion)) { node.Add(TextureShapeName, (int)TextureShape); } if (HasSingleChannelComponent(container.ExportVersion)) { node.Add(SingleChannelComponentName, SingleChannelComponent); } if (HasMaxTextureSizeSet(container.ExportVersion)) { node.Add(MaxTextureSizeSetName, MaxTextureSizeSet); node.Add(CompressionQualitySetName, CompressionQualitySet); node.Add(TextureFormatSetName, TextureFormatSet); } if (HasPlatformSettings(container.ExportVersion)) { node.Add(GetPlatformSettingsName(container.ExportVersion), PlatformSettings.ExportYAML(container)); } if (HasSprite(container.ExportVersion)) { node.Add(SpriteSheetName, SpriteSheet.ExportYAML(container)); node.Add(SpritePackingTagName, SpritePackingTag); } /*if (HasOutput(container.ExportVersion)) * { * node.Add(OutputName, Output.ExportYAML(container)); * }*/ if (HasPSDRemoveMatte(container.ExportVersion)) { node.Add(PSDRemoveMatteName, PSDRemoveMatte); node.Add(PSDShowRemoveMatteOptionName, PSDShowRemoveMatteOption); } PostExportYAML(container, node); return(node); }
public override void Write(AssetWriter writer) { base.Write(writer); bool isBoolFlags = IsBoolFlags(writer.Version); writer.Write((int)MipMapMode); if (isBoolFlags) { writer.Write(EnableMipMapBool); writer.Write(CorrectGammaBool); writer.Write(FadeOutBool); writer.Write(BorderMipMapBool); } else { writer.Write(EnableMipMap); if (HasSRGBTexture(writer.Version)) { writer.Write(SRGBTexture); } if (HasLinearTexture(writer.Version)) { writer.Write(LinearTexture); } if (HasCorrectGamma(writer.Version)) { writer.Write(CorrectGamma); } writer.Write(FadeOut); writer.Write(BorderMipMap); } if (HasMipMapsPreserveCoverage(writer.Version)) { writer.Write(MipMapsPreserveCoverage); writer.Write(AlphaTestReferenceValue); } writer.Write(MipMapFadeDistanceStart); writer.Write(MipMapFadeDistanceEnd); if (isBoolFlags) { writer.Write(ConvertToNormalMapBool); if (HasIsReadable(writer.Version)) { writer.Write(IsReadableBool); } } else { writer.Write(ConvertToNormalMap); writer.Write(ExternalNormalMap); if (IsReadableFirst(writer.Version)) { writer.Write(IsReadable); writer.AlignStream(); } } writer.Write(HeightScale); writer.Write((int)NormalMapFilter); if (!IsReadableFirst(writer.Version)) { writer.Write(IsReadable); } if (HasStreamingMipmaps(writer.Version)) { writer.Write(StreamingMipmaps); writer.Write(StreamingMipmapsPriority); } if (isBoolFlags) { writer.Write(GrayScaleToAlphaBool); } else { writer.Write(GrayScaleToAlpha); } if (IsAlignGrayScaleToAlpha(writer.Version)) { writer.AlignStream(); } writer.Write((int)GenerateCubemap); if (HasCubemapConvolution(writer.Version)) { writer.Write(CubemapConvolution); } if (HasCubemapConvolutionSteps(writer.Version)) { writer.Write(CubemapConvolutionSteps); writer.Write(CubemapConvolutionExponent); } if (HasSeamlessCubemap(writer.Version)) { writer.Write(SeamlessCubemap); } writer.Write((int)TextureFormat); if (IsAlignTextureFormat(writer.Version)) { writer.AlignStream(); } if (HasRecommendedTextureFormat(writer.Version) && RecommendedTextureFormatFirst(writer.Version)) { writer.Write(RecommendedTextureFormat); writer.AlignStream(); } writer.Write(MaxTextureSize); TextureSettings.Write(writer); writer.Write((int)NPOTScale); if (HasLightmap(writer.Version)) { writer.Write(Lightmap); } if (HasRGBM(writer.Version)) { writer.Write(RGBM); } if (HasCompressionQuality(writer.Version)) { writer.Write(CompressionQuality); } if (HasAllowsAlphaSplitting(writer.Version)) { writer.Write(AllowsAlphaSplitting); writer.AlignStream(); } if (HasSprite(writer.Version)) { writer.Write((int)SpriteMode); writer.Write(SpriteExtrude); writer.Write((int)SpriteMeshType); writer.Write((int)Alignment); SpritePivot.Write(writer); } if (HasSprite(writer.Version) && SpritePixelsToUnitsFirst(writer.Version)) { writer.Write(SpritePixelsToUnits); } if (HasSpriteBorder(writer.Version)) { SpriteBorder.Write(writer); } if (HasSprite(writer.Version) && !SpritePixelsToUnitsFirst(writer.Version)) { writer.Write(SpritePixelsToUnits); } if (HasSpriteGenerateFallbackPhysicsShape(writer.Version)) { writer.Write(SpriteGenerateFallbackPhysicsShape); } if (HasAlphaUsage(writer.Version)) { writer.Write((int)AlphaUsage); } if (HasAlphaIsTransparency(writer.Version)) { writer.Write(AlphaIsTransparency); } if (HasSpriteTessellationDetail(writer.Version)) { writer.Write(SpriteTessellationDetail); } if (HasTextureType(writer.Version)) { writer.Write((int)TextureType); } if (HasRecommendedTextureFormat(writer.Version) && !RecommendedTextureFormatFirst(writer.Version)) { writer.Write(RecommendedTextureFormat); } if (HasSourceTextureInformation(writer.Version)) { SourceTextureInformation.Write(writer); writer.AlignStream(); } if (HasTextureShape(writer.Version)) { writer.Write((int)TextureShape); } if (HasSingleChannelComponent(writer.Version)) { writer.Write(SingleChannelComponent); } if (HasMaxTextureSizeSet(writer.Version)) { writer.Write(MaxTextureSizeSet); writer.Write(CompressionQualitySet); writer.Write(TextureFormatSet); } writer.AlignStream(); if (HasPlatformSettings(writer.Version)) { PlatformSettings.Write(writer); } if (HasSprite(writer.Version)) { SpriteSheet.Write(writer); writer.Write(SpritePackingTag); } if (HasOutput(writer.Version)) { Output.Write(writer); } if (HasPSDRemoveMatte(writer.Version)) { writer.Write(PSDRemoveMatte); writer.Write(PSDShowRemoveMatteOption); } writer.AlignStream(); PostWrite(writer); }
public override void Read(AssetReader reader) { base.Read(reader); #if UNIVERSAL if (IsReadAlphaIsTransparency(reader.Version, reader.Flags)) { if (GetAlphaIsTransparencyPosition(reader.Version) == 0) { AlphaIsTransparency = reader.ReadBoolean(); reader.AlignStream(AlignType.Align4); } } #endif Width = reader.ReadInt32(); Height = reader.ReadInt32(); CompleteImageSize = reader.ReadInt32(); TextureFormat = (TextureFormat)reader.ReadInt32(); if (IsBoolMinMap(reader.Version)) { bool mipMap = reader.ReadBoolean(); if (mipMap) { int maxSide = Math.Max(Width, Height); MipCount = Convert.ToInt32(Math.Log(maxSide) / Math.Log(2)); } else { MipCount = 1; } } else { MipCount = reader.ReadInt32(); } if (IsReadIsReadable(reader.Version)) { IsReadable = reader.ReadBoolean(); } if (IsReadReadAllowed(reader.Version)) { ReadAllowed = reader.ReadBoolean(); } if (IsReadStreamingMipmaps(reader.Version)) { StreamingMipmaps = reader.ReadBoolean(); } #if UNIVERSAL if (IsReadAlphaIsTransparency(reader.Version, reader.Flags)) { if (GetAlphaIsTransparencyPosition(reader.Version) == 1) { AlphaIsTransparency = reader.ReadBoolean(); } } #endif reader.AlignStream(AlignType.Align4); if (IsReadStreamingMipmapsPriority(reader.Version)) { StreamingMipmapsPriority = reader.ReadInt32(); #if UNIVERSAL if (IsReadAlphaIsTransparency(reader.Version, reader.Flags)) { if (GetAlphaIsTransparencyPosition(reader.Version) == 2) { AlphaIsTransparency = reader.ReadBoolean(); } } #endif reader.AlignStream(AlignType.Align4); } ImageCount = reader.ReadInt32(); TextureDimension = (TextureDimension)reader.ReadInt32(); TextureSettings.Read(reader); if (IsReadLightmapFormat(reader.Version)) { LightmapFormat = (TextureUsageMode)reader.ReadInt32(); } if (IsReadColorSpace(reader.Version)) { ColorSpace = (ColorSpace)reader.ReadInt32(); } m_imageData = reader.ReadByteArray(); reader.AlignStream(AlignType.Align4); if (IsReadStreamData(reader.Version)) { StreamData.Read(reader); } }
/* Given a list of textures and settings, copy over each texture into a texture2darray and save it as a file **/ private void CopyListIntoArray(TextureList List, TextureSettings Settings) { if (List != null && List.TexArray.Length > 0) { if (List.TexArray[0] == null) { EditorUtility.DisplayDialog("First element unassigned", "Element 0 of the texture list is empty!", "ok"); return; } Texture2DArray output = new Texture2DArray(List.TexArray[0].width, List.TexArray[0].height, List.TexArray.Length, List.TexArray[0].format, Settings.copyMips); output.mipMapBias = Settings.mipMapBias; output.filterMode = Settings.filterMode; output.wrapModeU = Settings.wrapModeU; output.wrapModeV = Settings.wrapModeV; output.anisoLevel = Settings.anisoLevel; bool consistentSettings = true; for (int i = 0; i < List.TexArray.Length; i++) { /* Stop if one of the elements in the list is empty **/ if (List.TexArray[i] == null) { EditorUtility.DisplayDialog("Element unassigned", string.Format("Element {0} of the texture list is empty!", i), "ok"); return; } /* Stop if the texture being copied doesn't have the same settings as the first element of the array **/ consistentSettings = HasSameSettings(List.TexArray[0], List.TexArray[i], i); if (consistentSettings == false) { return; } /* Copy the contents of the texture into the corresponding slice of the Texture2DArray, and copy over all the mips if copyMips is true **/ if (Settings.copyMips) { for (int j = 0; j < List.TexArray[0].mipmapCount; j++) { Graphics.CopyTexture(List.TexArray[i], 0, j, output, i, j); } } else { Graphics.CopyTexture(List.TexArray[i], 0, 0, output, i, 0); } } output.Apply(false); string path = EditorUtility.SaveFilePanelInProject("Save Array", List.name + "_texarray.asset", "asset", "Please enter a file name to save the texture array to"); if (path.Length != 0) { AssetDatabase.CreateAsset(output, path); } } else { EditorUtility.DisplayDialog("No texture list selected", "You must enter a non-empty texture list", "ok"); } }
public TextureImportSettings(TextureSettings settings) { m_textureSettings = settings; }
public override void Read(AssetReader reader) { base.Read(reader); bool isBoolFlags = IsBoolFlags(reader.Version); MipMapMode = (TextureImporterMipFilter)reader.ReadInt32(); if (isBoolFlags) { EnableMipMapBool = reader.ReadBoolean(); CorrectGammaBool = reader.ReadBoolean(); FadeOutBool = reader.ReadBoolean(); BorderMipMapBool = reader.ReadBoolean(); } else { EnableMipMap = reader.ReadInt32(); if (HasSRGBTexture(reader.Version)) { SRGBTexture = reader.ReadInt32(); } if (HasLinearTexture(reader.Version)) { LinearTexture = reader.ReadInt32(); } if (HasCorrectGamma(reader.Version)) { CorrectGamma = reader.ReadInt32(); } FadeOut = reader.ReadInt32(); BorderMipMap = reader.ReadInt32(); } if (HasMipMapsPreserveCoverage(reader.Version)) { MipMapsPreserveCoverage = reader.ReadInt32(); AlphaTestReferenceValue = reader.ReadSingle(); } MipMapFadeDistanceStart = reader.ReadInt32(); MipMapFadeDistanceEnd = reader.ReadInt32(); if (isBoolFlags) { ConvertToNormalMapBool = reader.ReadBoolean(); if (HasIsReadable(reader.Version)) { IsReadableBool = reader.ReadBoolean(); } } else { ConvertToNormalMap = reader.ReadInt32(); ExternalNormalMap = reader.ReadInt32(); if (IsReadableFirst(reader.Version)) { IsReadable = reader.ReadInt32(); reader.AlignStream(); } } HeightScale = reader.ReadSingle(); NormalMapFilter = (TextureImporterNormalFilter)reader.ReadInt32(); if (!IsReadableFirst(reader.Version)) { IsReadable = reader.ReadInt32(); } if (HasStreamingMipmaps(reader.Version)) { StreamingMipmaps = reader.ReadInt32(); StreamingMipmapsPriority = reader.ReadInt32(); } if (isBoolFlags) { GrayScaleToAlphaBool = reader.ReadBoolean(); } else { GrayScaleToAlpha = reader.ReadInt32(); } if (IsAlignGrayScaleToAlpha(reader.Version)) { reader.AlignStream(); } GenerateCubemap = (TextureImporterGenerateCubemap)reader.ReadInt32(); if (HasCubemapConvolution(reader.Version)) { CubemapConvolution = reader.ReadInt32(); } if (HasCubemapConvolutionSteps(reader.Version)) { CubemapConvolutionSteps = reader.ReadInt32(); CubemapConvolutionExponent = reader.ReadSingle(); } if (HasSeamlessCubemap(reader.Version)) { SeamlessCubemap = reader.ReadInt32(); } TextureFormat = (TextureFormat)reader.ReadInt32(); if (IsAlignTextureFormat(reader.Version)) { reader.AlignStream(); } if (HasRecommendedTextureFormat(reader.Version) && RecommendedTextureFormatFirst(reader.Version)) { RecommendedTextureFormat = reader.ReadInt32(); reader.AlignStream(); } MaxTextureSize = reader.ReadInt32(); TextureSettings.Read(reader); NPOTScale = (TextureImporterNPOTScale)reader.ReadInt32(); if (HasLightmap(reader.Version)) { Lightmap = reader.ReadInt32(); } if (HasRGBM(reader.Version)) { RGBM = reader.ReadInt32(); } if (HasCompressionQuality(reader.Version)) { CompressionQuality = reader.ReadInt32(); } if (HasAllowsAlphaSplitting(reader.Version)) { AllowsAlphaSplitting = reader.ReadInt32(); reader.AlignStream(); } if (HasSprite(reader.Version)) { SpriteMode = (SpriteImportMode)reader.ReadInt32(); SpriteExtrude = reader.ReadUInt32(); SpriteMeshType = (SpriteMeshType)reader.ReadInt32(); Alignment = (SpriteAlignment)reader.ReadInt32(); SpritePivot.Read(reader); } if (HasSprite(reader.Version) && SpritePixelsToUnitsFirst(reader.Version)) { SpritePixelsToUnits = reader.ReadSingle(); } if (HasSpriteBorder(reader.Version)) { SpriteBorder.Read(reader); } if (HasSprite(reader.Version) && !SpritePixelsToUnitsFirst(reader.Version)) { SpritePixelsToUnits = reader.ReadSingle(); } if (HasSpriteGenerateFallbackPhysicsShape(reader.Version)) { SpriteGenerateFallbackPhysicsShape = reader.ReadInt32(); } if (HasAlphaUsage(reader.Version)) { AlphaUsage = (TextureImporterAlphaSource)reader.ReadInt32(); } if (HasAlphaIsTransparency(reader.Version)) { AlphaIsTransparency = reader.ReadInt32(); } if (HasSpriteTessellationDetail(reader.Version)) { SpriteTessellationDetail = reader.ReadSingle(); } if (HasTextureType(reader.Version)) { TextureType = (TextureImporterType)reader.ReadInt32(); } if (HasRecommendedTextureFormat(reader.Version) && !RecommendedTextureFormatFirst(reader.Version)) { RecommendedTextureFormat = reader.ReadInt32(); } if (HasSourceTextureInformation(reader.Version)) { SourceTextureInformation = reader.ReadAsset <SourceTextureInformation>(); reader.AlignStream(); } if (HasTextureShape(reader.Version)) { TextureShape = (TextureImporterShape)reader.ReadInt32(); } if (HasSingleChannelComponent(reader.Version)) { SingleChannelComponent = reader.ReadInt32(); } if (HasMaxTextureSizeSet(reader.Version)) { MaxTextureSizeSet = reader.ReadInt32(); CompressionQualitySet = reader.ReadInt32(); TextureFormatSet = reader.ReadInt32(); } reader.AlignStream(); if (HasPlatformSettings(reader.Version)) { PlatformSettings = reader.ReadAssetArray <TextureImporterPlatformSettings>(); } if (HasSprite(reader.Version)) { SpriteSheet.Read(reader); SpritePackingTag = reader.ReadString(); } if (HasOutput(reader.Version)) { Output.Read(reader); } if (HasPSDRemoveMatte(reader.Version)) { PSDRemoveMatte = reader.ReadBoolean(); PSDShowRemoveMatteOption = reader.ReadBoolean(); } reader.AlignStream(); PostRead(reader); }
// Called with new atlas. Guesses the appropriate transparency type for // the atlas and select the shader based on this. private void PrepNewTexture() { if (!AutoOptimizeImages && !AutoGuessTransparency && !AutoGuessLayout) { return; } // Grab values to check against var atlas = Atlas as Texture2D; if (atlas == null) { return; } if (GetComponent <Renderer>() == null) { return; } Material material = GetComponent <Renderer>().sharedMaterial; if (material == null) { return; } TextureSettings.AddTemporaryReadableToTexture(atlas); // Optimize texture properties if (AutoOptimizeImages) { TextureSettings.SetAtlasAsOptimalForBbSprite(Atlas); } // Determine which shader to use if (AutoGuessTransparency) { if (atlas.GetPixel(0, 0).a != 1) { material.shader = Shader.Find("Sprites/BbSprites/Alpha"); } else { Shader defaultColorShader = Shader.Find("Sprites/BbSprites/ColorKey_UL"); if ( material.shader != defaultColorShader && material.shader != Shader.Find("Sprites/BbSprites/ColorKey_UR") && material.shader != Shader.Find("Sprites/BbSprites/ColorKey_LL") && material.shader != Shader.Find("Sprites/BbSprites/ColorKey_LR") && material.shader != Shader.Find("Sprites/BbSprites/ColorKey_Custom")) { material.shader = defaultColorShader; } } } // Determine which layout type to use if (AutoGuessLayout) { var layout = GetComponent <BbSpriteLayout>(); if (layout == null) { return; } var width = atlas.width; var hasKeyColor = (material.shader != Shader.Find("Sprites/BbSprites/Alpha")); // check for rpgmaker if ( !TextureSettings.CheckTextureColumnForOpacity( atlas, (int)(width * .33333f), hasKeyColor) && !TextureSettings.CheckTextureColumnForOpacity( atlas, (int)(width * .66666f), hasKeyColor) ) { layout.MyType = BbSpriteLayout.Type.RpgMaker; layout.Update(); } // check for 4 by 4 else if ( !TextureSettings.CheckTextureColumnForOpacity( atlas, (int)(width * .5f), hasKeyColor) && !TextureSettings.CheckTextureColumnForOpacity( atlas, (int)(width * .25f), hasKeyColor) && !TextureSettings.CheckTextureColumnForOpacity( atlas, (int)(width * .75f), hasKeyColor) ) { layout.MyType = BbSpriteLayout.Type.FourByFour; layout.Update(); } // If failed other checks, is single cell else { layout.MyType = BbSpriteLayout.Type.SingleCell; layout.Update(); } } TextureSettings.RemoveTemporaryReadableFromTexture(atlas); }