private void OnEnable()
{
this.m_MaxTextureSize = base.serializedObject.FindProperty("m_EditorData.textureSettings.maxTextureSize");
this.m_TextureCompression = base.serializedObject.FindProperty("m_EditorData.textureSettings.textureCompression");
this.m_UseCrunchedCompression = base.serializedObject.FindProperty("m_EditorData.textureSettings.crunchedCompression");
this.m_CompressionQuality = base.serializedObject.FindProperty("m_EditorData.textureSettings.compressionQuality");
this.m_FilterMode = base.serializedObject.FindProperty("m_EditorData.textureSettings.filterMode");
this.m_AnisoLevel = base.serializedObject.FindProperty("m_EditorData.textureSettings.anisoLevel");
this.m_GenerateMipMaps = base.serializedObject.FindProperty("m_EditorData.textureSettings.generateMipMaps");
this.m_Readable = base.serializedObject.FindProperty("m_EditorData.textureSettings.readable");
this.m_UseSRGB = base.serializedObject.FindProperty("m_EditorData.textureSettings.sRGB");
this.m_EnableTightPacking = base.serializedObject.FindProperty("m_EditorData.packingParameters.enableTightPacking");
this.m_EnableRotation = base.serializedObject.FindProperty("m_EditorData.packingParameters.enableRotation");
this.m_Padding = base.serializedObject.FindProperty("m_EditorData.packingParameters.padding");
this.m_MasterAtlas = base.serializedObject.FindProperty("m_MasterAtlas");
this.m_BindAsDefault = base.serializedObject.FindProperty("m_EditorData.bindAsDefault");
this.m_VariantMultiplier = base.serializedObject.FindProperty("m_EditorData.variantMultiplier");
this.m_Packables = base.serializedObject.FindProperty("m_EditorData.packables");
this.m_PackableList = new ReorderableList(base.serializedObject, this.m_Packables, true, true, true, true);
this.m_PackableList.onAddCallback = new ReorderableList.AddCallbackDelegate(this.AddPackable);
this.m_PackableList.onRemoveCallback = new ReorderableList.RemoveCallbackDelegate(this.RemovePackable);
this.m_PackableList.drawElementCallback = new ReorderableList.ElementCallbackDelegate(this.DrawPackableElement);
this.m_PackableList.elementHeight = EditorGUIUtility.singleLineHeight;
this.m_PackableList.headerHeight = 0f;
this.SyncPlatformSettings();
TextureImporterInspector.InitializeTextureFormatStrings();
this.m_TexturePlatformSettingsView = new SpriteAtlasInspector.SpriteAtlasInspectorPlatformSettingView(this.AllTargetsAreMaster());
this.m_TexturePlatformSettingTextureHelper = new TexturePlatformSettingsFormatHelper();
this.m_TexturePlatformSettingsController = new TexturePlatformSettingsViewController();
}
void OnEnable()
{
m_FilterMode = serializedObject.FindProperty("m_EditorData.textureSettings.filterMode");
m_AnisoLevel = serializedObject.FindProperty("m_EditorData.textureSettings.anisoLevel");
m_GenerateMipMaps = serializedObject.FindProperty("m_EditorData.textureSettings.generateMipMaps");
m_Readable = serializedObject.FindProperty("m_EditorData.textureSettings.readable");
m_UseSRGB = serializedObject.FindProperty("m_EditorData.textureSettings.sRGB");
m_EnableTightPacking = serializedObject.FindProperty("m_EditorData.packingSettings.enableTightPacking");
m_EnableRotation = serializedObject.FindProperty("m_EditorData.packingSettings.enableRotation");
m_Padding = serializedObject.FindProperty("m_EditorData.packingSettings.padding");
m_MasterAtlas = serializedObject.FindProperty("m_MasterAtlas");
m_BindAsDefault = serializedObject.FindProperty("m_EditorData.bindAsDefault");
m_VariantScale = serializedObject.FindProperty("m_EditorData.variantMultiplier");
m_Packables = serializedObject.FindProperty("m_EditorData.packables");
m_PackableList = new ReorderableList(serializedObject, m_Packables, true, false, true, true);
m_PackableList.onAddCallback = AddPackable;
m_PackableList.onRemoveCallback = RemovePackable;
m_PackableList.drawElementCallback = DrawPackableElement;
m_PackableList.elementHeight = EditorGUIUtility.singleLineHeight;
m_PackableList.headerHeight = 3f;
SyncPlatformSettings();
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(AllTargetsAreMaster());
m_TexturePlatformSettingTextureHelper = new TexturePlatformSettingsFormatHelper();
m_TexturePlatformSettingsController = new TexturePlatformSettingsViewController();
}
private void HandleCommonSettingUI()
{
var atlasType = AtlasType.Undefined;
if (AllTargetsAreMaster())
{
atlasType = AtlasType.Master;
}
else if (AllTargetsAreVariant())
{
atlasType = AtlasType.Variant;
}
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = atlasType == AtlasType.Undefined;
atlasType = (AtlasType)EditorGUILayout.IntPopup(styles.atlasTypeLabel, (int)atlasType, styles.atlasTypeOptions, styles.atlasTypeValues);
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
{
bool setToVariant = atlasType == AtlasType.Variant;
foreach (SpriteAtlas sa in targets)
{
sa.SetIsVariant(setToVariant);
}
// Reinit the platform setting view
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(AllTargetsAreMaster());
}
if (atlasType == AtlasType.Variant)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_MasterAtlas, styles.masterAtlasLabel);
if (EditorGUI.EndChangeCheck())
{
// Apply modified properties here to have latest master atlas reflected in native codes.
serializedObject.ApplyModifiedProperties();
foreach (SpriteAtlas sa in targets)
{
sa.CopyMasterAtlasSettings();
}
PopulatePlatformSettingsOptions();
SyncPlatformSettings();
}
}
EditorGUILayout.PropertyField(m_BindAsDefault, styles.bindAsDefaultLabel);
}
private void HandleCommonSettingUI()
{
SpriteAtlasInspector.AtlasType atlasType = SpriteAtlasInspector.AtlasType.Undefined;
if (this.AllTargetsAreMaster())
{
atlasType = SpriteAtlasInspector.AtlasType.Master;
}
else if (this.AllTargetsAreVariant())
{
atlasType = SpriteAtlasInspector.AtlasType.Variant;
}
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = (atlasType == SpriteAtlasInspector.AtlasType.Undefined);
atlasType = (SpriteAtlasInspector.AtlasType)EditorGUILayout.IntPopup(SpriteAtlasInspector.s_Styles.atlasTypeLabel, (int)atlasType, SpriteAtlasInspector.s_Styles.atlasTypeOptions, SpriteAtlasInspector.s_Styles.atlasTypeValues, new GUILayoutOption[0]);
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
{
bool value = atlasType == SpriteAtlasInspector.AtlasType.Variant;
UnityEngine.Object[] targets = base.targets;
for (int i = 0; i < targets.Length; i++)
{
SpriteAtlas spriteAtlas = (SpriteAtlas)targets[i];
spriteAtlas.SetIsVariant(value);
}
this.m_TexturePlatformSettingsView = new SpriteAtlasInspector.SpriteAtlasInspectorPlatformSettingView(this.AllTargetsAreMaster());
}
if (atlasType == SpriteAtlasInspector.AtlasType.Variant)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.m_MasterAtlas, SpriteAtlasInspector.s_Styles.masterAtlasLabel, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
base.serializedObject.ApplyModifiedProperties();
UnityEngine.Object[] targets2 = base.targets;
for (int j = 0; j < targets2.Length; j++)
{
SpriteAtlas spriteAtlas2 = (SpriteAtlas)targets2[j];
spriteAtlas2.CopyMasterAtlasSettings();
this.SyncPlatformSettings();
}
}
}
EditorGUILayout.PropertyField(this.m_BindAsDefault, SpriteAtlasInspector.s_Styles.bindAsDefaultLabel, new GUILayoutOption[0]);
}
public override void OnEnable()
{
base.OnEnable();
m_FilterMode = serializedObject.FindProperty("m_TextureSettings.filterMode");
m_AnisoLevel = serializedObject.FindProperty("m_TextureSettings.anisoLevel");
m_GenerateMipMaps = serializedObject.FindProperty("m_TextureSettings.generateMipMaps");
m_Readable = serializedObject.FindProperty("m_TextureSettings.readable");
m_UseSRGB = serializedObject.FindProperty("m_TextureSettings.sRGB");
m_EnableTightPacking = serializedObject.FindProperty("m_PackingSettings.enableTightPacking");
m_EnableRotation = serializedObject.FindProperty("m_PackingSettings.enableRotation");
m_EnableAlphaDilation = serializedObject.FindProperty("m_PackingSettings.enableAlphaDilation");
m_Padding = serializedObject.FindProperty("m_PackingSettings.padding");
m_BindAsDefault = serializedObject.FindProperty("m_BindAsDefault");
m_VariantScale = serializedObject.FindProperty("m_VariantMultiplier");
PopulatePlatformSettingsOptions();
SyncPlatformSettings();
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(IsTargetMaster());
m_TexturePlatformSettingTextureHelper = new TexturePlatformSettingsFormatHelper();
m_TexturePlatformSettingsController = new TexturePlatformSettingsViewController();
// Don't show max size option for secondary textures as they must have the same size as the main texture.
m_SecondaryTexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(false);
m_AssetPath = LoadSourceAsset();
if (spriteAtlasAsset == null)
{
return;
}
m_MasterAtlas = serializedAssetObject.FindProperty("m_MasterAtlas");
m_Packables = serializedAssetObject.FindProperty("m_ImporterData.packables");
m_PackableList = new ReorderableList(serializedAssetObject, m_Packables, true, true, true, true);
m_PackableList.onAddCallback = AddPackable;
m_PackableList.drawElementCallback = DrawPackableElement;
m_PackableList.elementHeight = EditorGUIUtility.singleLineHeight;
m_PackableList.headerHeight = 0f;
}
private void HandleCommonSettingUI()
{
var atlasType = AtlasType.Undefined;
if (IsTargetMaster())
{
atlasType = AtlasType.Master;
}
else if (IsTargetVariant())
{
atlasType = AtlasType.Variant;
}
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = atlasType == AtlasType.Undefined;
atlasType = (AtlasType)EditorGUILayout.IntPopup(styles.atlasTypeLabel, (int)atlasType, styles.atlasTypeOptions, styles.atlasTypeValues);
EditorGUI.showMixedValue = false;
if (EditorGUI.EndChangeCheck())
{
bool setToVariant = atlasType == AtlasType.Variant;
spriteAtlasAsset.SetIsVariant(setToVariant);
// Reinit the platform setting view
m_TexturePlatformSettingsView = new SpriteAtlasInspectorPlatformSettingView(IsTargetMaster());
}
if (atlasType == AtlasType.Variant)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(m_MasterAtlas, styles.masterAtlasLabel);
if (EditorGUI.EndChangeCheck())
{
ValidateMasterAtlas();
// Apply modified properties here to have latest master atlas reflected in native codes.
serializedAssetObject.ApplyModifiedPropertiesWithoutUndo();
PopulatePlatformSettingsOptions();
SyncPlatformSettings();
}
}
}
public bool HandleDefaultSettings(List <TextureImporterPlatformSettings> platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper)
{
Assert.IsTrue(platformSettings.Count > 0, "At least 1 platform setting is needed to display the texture platform setting UI.");
var allSize = platformSettings[0].maxTextureSize;
var allFormat = platformSettings[0].format;
var allCompression = platformSettings[0].textureCompression;
var allUseCrunchedCompression = platformSettings[0].crunchedCompression;
var allCompressionQuality = platformSettings[0].compressionQuality;
var mixedSize = false;
var mixedFormat = false;
var mixedCompression = false;
var mixedUseCrunchedCompression = false;
var mixedCompressionQuality = false;
var sizeChanged = false;
var formatChanged = false;
var compressionChanged = false;
var useCrunchedCompressionChanged = false;
var compressionQualityChanged = false;
for (var i = 1; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (settings.maxTextureSize != allSize)
{
mixedSize = true;
}
if (settings.format != allFormat)
{
mixedFormat = true;
}
if (settings.textureCompression != allCompression)
{
mixedCompression = true;
}
if (settings.crunchedCompression != allUseCrunchedCompression)
{
mixedUseCrunchedCompression = true;
}
if (settings.compressionQuality != allCompressionQuality)
{
mixedCompressionQuality = true;
}
}
allSize = view.DrawMaxSize(allSize, mixedSize, false, out sizeChanged);
int[] formatValues = null;
string[] formatStrings = null;
formatHelper.AcquireDefaultTextureFormatValuesAndStrings(out formatValues, out formatStrings);
allFormat = view.DrawFormat(allFormat, formatValues, formatStrings, mixedFormat, false, out formatChanged);
if (allFormat == TextureImporterFormat.Automatic && (!mixedFormat || formatChanged))
{
allCompression = view.DrawCompression(allCompression, mixedCompression, false, out compressionChanged);
if (allCompression != TextureImporterCompression.Uncompressed && (!mixedCompression || compressionChanged))
{
allUseCrunchedCompression = view.DrawUseCrunchedCompression(allUseCrunchedCompression,
mixedUseCrunchedCompression, false, out useCrunchedCompressionChanged);
if (allUseCrunchedCompression && (!mixedUseCrunchedCompression || useCrunchedCompressionChanged))
{
allCompressionQuality = view.DrawCompressionQualitySlider(allCompressionQuality,
mixedCompressionQuality, false, out compressionQualityChanged);
}
}
}
if (sizeChanged || compressionChanged || formatChanged || useCrunchedCompressionChanged || compressionQualityChanged)
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (sizeChanged)
{
platformSettings[i].maxTextureSize = allSize;
}
if (formatChanged)
{
platformSettings[i].format = allFormat;
}
if (compressionChanged)
{
platformSettings[i].textureCompression = allCompression;
}
if (useCrunchedCompressionChanged)
{
platformSettings[i].crunchedCompression = allUseCrunchedCompression;
}
if (compressionQualityChanged)
{
platformSettings[i].compressionQuality = allCompressionQuality;
}
}
return(true);
}
else
{
return(false);
}
}
public bool HandlePlatformSettings(BuildTarget buildTarget, List <TextureImporterPlatformSettings> platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper)
{
Assert.IsTrue(platformSettings.Count > 0, "At least 1 platform setting is needed to display the texture platform setting UI.");
var allOverride = platformSettings[0].overridden;
var allSize = platformSettings[0].maxTextureSize;
var allFormat = platformSettings[0].format;
var allCompressionQuality = platformSettings[0].compressionQuality;
var allAlphaSplit = platformSettings[0].allowsAlphaSplitting;
var mixedOverride = false;
var mixedSize = false;
var mixedFormat = false;
var mixedCompression = false;
var mixedAlphaSplit = false;
var overrideChanged = false;
var sizeChanged = false;
var formatChanged = false;
var compressionChanged = false;
var alphaSplitChanged = false;
for (var i = 1; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (settings.overridden != allOverride)
{
mixedOverride = true;
}
if (settings.maxTextureSize != allSize)
{
mixedSize = true;
}
if (settings.format != allFormat)
{
mixedFormat = true;
}
if (settings.compressionQuality != allCompressionQuality)
{
mixedCompression = true;
}
if (settings.allowsAlphaSplitting != allAlphaSplit)
{
mixedAlphaSplit = true;
}
}
allOverride = view.DrawOverride(allOverride, mixedOverride, out overrideChanged);
allSize = view.DrawMaxSize(allSize, mixedSize, mixedOverride || !allOverride, out sizeChanged);
int[] formatValues = null;
string[] formatStrings = null;
formatHelper.AcquireTextureFormatValuesAndStrings(buildTarget, out formatValues, out formatStrings);
allFormat = view.DrawFormat(allFormat, formatValues, formatStrings, mixedFormat, mixedOverride || !allOverride, out formatChanged);
if (!mixedFormat && formatHelper.TextureFormatRequireCompressionQualityInput(allFormat))
{
bool showAsEnum = BuildTargetDiscovery.PlatformHasFlag(buildTarget, TargetAttributes.HasIntegratedGPU);
if (showAsEnum)
{
var compressionMode = 1;
if (allCompressionQuality == (int)TextureCompressionQuality.Fast)
{
compressionMode = 0;
}
else if (allCompressionQuality == (int)TextureCompressionQuality.Best)
{
compressionMode = 2;
}
compressionMode = view.DrawCompressionQualityPopup(compressionMode, mixedCompression, mixedOverride || !allOverride, out compressionChanged);
if (compressionChanged)
{
switch (compressionMode)
{
case 0: allCompressionQuality = (int)TextureCompressionQuality.Fast; break;
case 1: allCompressionQuality = (int)TextureCompressionQuality.Normal; break;
case 2: allCompressionQuality = (int)TextureCompressionQuality.Best; break;
default:
Assert.IsTrue(false, "ITexturePlatformSettingsView.DrawCompressionQualityPopup should never return compression option value that's not 0, 1 or 2.");
break;
}
}
}
else
{
allCompressionQuality = view.DrawCompressionQualitySlider(allCompressionQuality, mixedCompression, mixedOverride || !allOverride, out compressionChanged);
}
// show the ETC1 split option only for sprites on platforms supporting ETC.
bool isETCPlatform = TextureImporter.IsETC1SupportedByBuildTarget(buildTarget);
bool isETCFormatSelected = TextureImporter.IsTextureFormatETC1Compression((TextureFormat)allFormat);
if (isETCPlatform && isETCFormatSelected)
{
allAlphaSplit = view.DrawAlphaSplit(allAlphaSplit, mixedAlphaSplit, mixedOverride || !allOverride, out alphaSplitChanged);
}
}
if (overrideChanged || sizeChanged || formatChanged || compressionChanged || alphaSplitChanged)
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (overrideChanged)
{
platformSettings[i].overridden = allOverride;
}
if (sizeChanged)
{
platformSettings[i].maxTextureSize = allSize;
}
if (formatChanged)
{
platformSettings[i].format = allFormat;
}
if (compressionChanged)
{
platformSettings[i].compressionQuality = allCompressionQuality;
}
if (alphaSplitChanged)
{
platformSettings[i].allowsAlphaSplitting = allAlphaSplit;
}
}
return(true);
}
else
{
return(false);
}
}
private void HandlePlatformSettingUI(string secondaryTextureName)
{
int shownTextureFormatPage = EditorGUILayout.BeginPlatformGrouping(m_ValidPlatforms.ToArray(), styles.defaultPlatformLabel);
var defaultPlatformSettings = m_TempPlatformSettings[TextureImporterInspector.s_DefaultPlatformName];
bool isSecondary = secondaryTextureName != null;
ITexturePlatformSettingsView view = isSecondary ? m_SecondaryTexturePlatformSettingsView : m_TexturePlatformSettingsView;
if (shownTextureFormatPage == -1)
{
if (m_TexturePlatformSettingsController.HandleDefaultSettings(defaultPlatformSettings, m_TexturePlatformSettingsView, m_TexturePlatformSettingTextureHelper))
{
for (var i = 0; i < defaultPlatformSettings.Count; ++i)
{
if (isSecondary)
{
spriteAtlasImporter.SetSecondaryPlatformSettings(defaultPlatformSettings[i], secondaryTextureName);
}
else
{
spriteAtlasImporter.SetPlatformSettings(defaultPlatformSettings[i]);
}
}
}
}
else
{
var buildPlatform = m_ValidPlatforms[shownTextureFormatPage];
var platformSettings = m_TempPlatformSettings[buildPlatform.name];
for (var i = 0; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (!settings.overridden)
{
if (defaultPlatformSettings[0].format == TextureImporterFormat.Automatic)
{
settings.format = (TextureImporterFormat)spriteAtlasImporter.GetTextureFormat(buildPlatform.defaultTarget);
}
else
{
settings.format = defaultPlatformSettings[0].format;
}
settings.maxTextureSize = defaultPlatformSettings[0].maxTextureSize;
settings.crunchedCompression = defaultPlatformSettings[0].crunchedCompression;
settings.compressionQuality = defaultPlatformSettings[0].compressionQuality;
}
}
m_TexturePlatformSettingsView.buildPlatformTitle = buildPlatform.title.text;
if (m_TexturePlatformSettingsController.HandlePlatformSettings(buildPlatform.defaultTarget, platformSettings, m_TexturePlatformSettingsView, m_TexturePlatformSettingTextureHelper))
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (isSecondary)
{
spriteAtlasImporter.SetSecondaryPlatformSettings(platformSettings[i], secondaryTextureName);
}
else
{
spriteAtlasImporter.SetPlatformSettings(platformSettings[i]);
}
}
}
}
EditorGUILayout.EndPlatformGrouping();
}
public bool HandlePlatformSettings(BuildTarget buildTarget, List <TextureImporterPlatformSettings> platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper)
{
bool overridden = platformSettings[0].overridden;
int maxTextureSize = platformSettings[0].maxTextureSize;
TextureImporterFormat format = platformSettings[0].format;
int compressionQuality = platformSettings[0].compressionQuality;
int maxTextureSize2 = maxTextureSize;
int compressionQuality2 = compressionQuality;
bool flag = false;
bool isMixedValue = false;
bool flag2 = false;
bool isMixedValue2 = false;
bool flag3 = false;
bool flag4 = false;
bool flag5 = false;
bool flag6 = false;
for (int i = 1; i < platformSettings.Count; i++)
{
TextureImporterPlatformSettings textureImporterPlatformSettings = platformSettings[i];
if (textureImporterPlatformSettings.overridden != overridden)
{
flag = true;
}
if (textureImporterPlatformSettings.maxTextureSize != maxTextureSize)
{
isMixedValue = true;
}
if (textureImporterPlatformSettings.format != format)
{
flag2 = true;
}
if (textureImporterPlatformSettings.compressionQuality != compressionQuality)
{
isMixedValue2 = true;
}
}
bool overridden2 = view.DrawOverride(overridden, flag, out flag3);
if (!flag && overridden)
{
maxTextureSize2 = view.DrawMaxSize(maxTextureSize, isMixedValue, out flag4);
}
int[] displayValues = null;
string[] displayStrings = null;
formatHelper.AcquireTextureFormatValuesAndStrings(buildTarget, out displayValues, out displayStrings);
TextureImporterFormat format2 = view.DrawFormat(format, displayValues, displayStrings, flag2, flag || !overridden, out flag5);
if (!flag2 && !flag && overridden && formatHelper.TextureFormatRequireCompressionQualityInput(format))
{
bool flag7 = buildTarget == BuildTarget.iOS || buildTarget == BuildTarget.tvOS || buildTarget == BuildTarget.Android || buildTarget == BuildTarget.Tizen;
if (flag7)
{
int defaultValue = 1;
if (compressionQuality == 0)
{
defaultValue = 0;
}
else if (compressionQuality == 100)
{
defaultValue = 2;
}
int num = view.DrawCompressionQualityPopup(defaultValue, isMixedValue2, out flag6);
if (flag6)
{
switch (num)
{
case 0:
compressionQuality2 = 0;
break;
case 1:
compressionQuality2 = 50;
break;
case 2:
compressionQuality2 = 100;
break;
}
}
}
else
{
compressionQuality2 = view.DrawCompressionQualitySlider(compressionQuality, isMixedValue2, out flag6);
}
}
bool result;
if (flag3 || flag4 || flag5 || flag6)
{
for (int j = 0; j < platformSettings.Count; j++)
{
if (flag3)
{
platformSettings[j].overridden = overridden2;
}
if (flag4)
{
platformSettings[j].maxTextureSize = maxTextureSize2;
}
if (flag5)
{
platformSettings[j].format = format2;
}
if (flag6)
{
platformSettings[j].compressionQuality = compressionQuality2;
}
}
result = true;
}
else
{
result = false;
}
return(result);
}
public bool HandleDefaultSettings(List <TextureImporterPlatformSettings> platformSettings, ITexturePlatformSettingsView view)
{
int maxTextureSize = platformSettings[0].maxTextureSize;
TextureImporterCompression textureCompression = platformSettings[0].textureCompression;
bool crunchedCompression = platformSettings[0].crunchedCompression;
int compressionQuality = platformSettings[0].compressionQuality;
bool crunchedCompression2 = crunchedCompression;
int compressionQuality2 = compressionQuality;
bool isMixedValue = false;
bool flag = false;
bool flag2 = false;
bool isMixedValue2 = false;
bool flag3 = false;
bool flag4 = false;
bool flag5 = false;
bool flag6 = false;
for (int i = 1; i < platformSettings.Count; i++)
{
TextureImporterPlatformSettings textureImporterPlatformSettings = platformSettings[i];
if (textureImporterPlatformSettings.maxTextureSize != maxTextureSize)
{
isMixedValue = true;
}
if (textureImporterPlatformSettings.textureCompression != textureCompression)
{
flag = true;
}
if (textureImporterPlatformSettings.crunchedCompression != crunchedCompression)
{
flag2 = true;
}
if (textureImporterPlatformSettings.compressionQuality != compressionQuality)
{
isMixedValue2 = true;
}
}
int maxTextureSize2 = view.DrawMaxSize(maxTextureSize, isMixedValue, out flag3);
TextureImporterCompression textureCompression2 = view.DrawCompression(textureCompression, flag, out flag4);
if (!flag && textureCompression != TextureImporterCompression.Uncompressed)
{
crunchedCompression2 = view.DrawUseCrunchedCompression(crunchedCompression, flag2, out flag5);
if (!flag2 && crunchedCompression)
{
compressionQuality2 = view.DrawCompressionQualitySlider(compressionQuality, isMixedValue2, out flag6);
}
}
bool result;
if (flag3 || flag4 || flag5 || flag6)
{
for (int j = 0; j < platformSettings.Count; j++)
{
if (flag3)
{
platformSettings[j].maxTextureSize = maxTextureSize2;
}
if (flag4)
{
platformSettings[j].textureCompression = textureCompression2;
}
if (flag5)
{
platformSettings[j].crunchedCompression = crunchedCompression2;
}
if (flag6)
{
platformSettings[j].compressionQuality = compressionQuality2;
}
}
result = true;
}
else
{
result = false;
}
return(result);
}
public bool HandlePlatformSettings(BuildTarget buildTarget, List <TextureImporterPlatformSettings> platformSettings, ITexturePlatformSettingsView view, ITexturePlatformSettingsFormatHelper formatHelper)
{
Assert.IsTrue(platformSettings.Count > 0, "At least 1 platform setting is needed to display the texture platform setting UI.");
var allOverride = platformSettings[0].overridden;
var allSize = platformSettings[0].maxTextureSize;
var allFormat = platformSettings[0].format;
var allCompressionQuality = platformSettings[0].compressionQuality;
var newOverride = allOverride;
var newSize = allSize;
var newFormat = allFormat;
var newCompressionQuality = allCompressionQuality;
var mixedOverride = false;
var mixedSize = false;
var mixedFormat = false;
var mixedCompression = false;
var overrideChanged = false;
var sizeChanged = false;
var formatChanged = false;
var compressionChanged = false;
for (var i = 1; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (settings.overridden != allOverride)
{
mixedOverride = true;
}
if (settings.maxTextureSize != allSize)
{
mixedSize = true;
}
if (settings.format != allFormat)
{
mixedFormat = true;
}
if (settings.compressionQuality != allCompressionQuality)
{
mixedCompression = true;
}
}
newOverride = view.DrawOverride(allOverride, mixedOverride, out overrideChanged);
if (!mixedOverride && allOverride)
{
newSize = view.DrawMaxSize(allSize, mixedSize, out sizeChanged);
}
int[] formatValues = null;
string[] formatStrings = null;
formatHelper.AcquireTextureFormatValuesAndStrings(buildTarget, out formatValues, out formatStrings);
newFormat = view.DrawFormat(allFormat, formatValues, formatStrings, mixedFormat, mixedOverride || !allOverride, out formatChanged);
if (!mixedFormat && !mixedOverride && allOverride && formatHelper.TextureFormatRequireCompressionQualityInput(allFormat))
{
bool showAsEnum =
buildTarget == BuildTarget.iOS ||
buildTarget == BuildTarget.tvOS ||
buildTarget == BuildTarget.Android
;
if (showAsEnum)
{
var compressionMode = 1;
if (allCompressionQuality == (int)TextureCompressionQuality.Fast)
{
compressionMode = 0;
}
else if (allCompressionQuality == (int)TextureCompressionQuality.Best)
{
compressionMode = 2;
}
var returnValue = view.DrawCompressionQualityPopup(compressionMode, mixedCompression, out compressionChanged);
if (compressionChanged)
{
switch (returnValue)
{
case 0: newCompressionQuality = (int)TextureCompressionQuality.Fast; break;
case 1: newCompressionQuality = (int)TextureCompressionQuality.Normal; break;
case 2: newCompressionQuality = (int)TextureCompressionQuality.Best; break;
default:
Assert.IsTrue(false, "ITexturePlatformSettingsView.DrawCompressionQualityPopup should never return compression option value that's not 0, 1 or 2.");
break;
}
}
}
else
{
newCompressionQuality = view.DrawCompressionQualitySlider(allCompressionQuality, mixedCompression, out compressionChanged);
}
}
if (overrideChanged || sizeChanged || formatChanged || compressionChanged)
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (overrideChanged)
{
platformSettings[i].overridden = newOverride;
}
if (sizeChanged)
{
platformSettings[i].maxTextureSize = newSize;
}
if (formatChanged)
{
platformSettings[i].format = newFormat;
}
if (compressionChanged)
{
platformSettings[i].compressionQuality = newCompressionQuality;
}
}
return(true);
}
else
{
return(false);
}
}
public bool HandleDefaultSettings(List <TextureImporterPlatformSettings> platformSettings, ITexturePlatformSettingsView view)
{
Assert.IsTrue(platformSettings.Count > 0, "At least 1 platform setting is needed to display the texture platform setting UI.");
var allSize = platformSettings[0].maxTextureSize;
var allCompression = platformSettings[0].textureCompression;
var allUseCrunchedCompression = platformSettings[0].crunchedCompression;
var allCompressionQuality = platformSettings[0].compressionQuality;
var newSize = allSize;
var newCompression = allCompression;
var newUseCrunchedCompression = allUseCrunchedCompression;
var newCompressionQuality = allCompressionQuality;
var mixedSize = false;
var mixedCompression = false;
var mixedUseCrunchedCompression = false;
var mixedCompressionQuality = false;
var sizeChanged = false;
var compressionChanged = false;
var useCrunchedCompressionChanged = false;
var compressionQualityChanged = false;
for (var i = 1; i < platformSettings.Count; ++i)
{
var settings = platformSettings[i];
if (settings.maxTextureSize != allSize)
{
mixedSize = true;
}
if (settings.textureCompression != allCompression)
{
mixedCompression = true;
}
if (settings.crunchedCompression != allUseCrunchedCompression)
{
mixedUseCrunchedCompression = true;
}
if (settings.compressionQuality != allCompressionQuality)
{
mixedCompressionQuality = true;
}
}
newSize = view.DrawMaxSize(allSize, mixedSize, out sizeChanged);
newCompression = view.DrawCompression(allCompression, mixedCompression, out compressionChanged);
if (!mixedCompression && allCompression != TextureImporterCompression.Uncompressed)
{
newUseCrunchedCompression = view.DrawUseCrunchedCompression(allUseCrunchedCompression, mixedUseCrunchedCompression, out useCrunchedCompressionChanged);
if (!mixedUseCrunchedCompression && allUseCrunchedCompression)
{
newCompressionQuality = view.DrawCompressionQualitySlider(allCompressionQuality, mixedCompressionQuality, out compressionQualityChanged);
}
}
if (sizeChanged || compressionChanged || useCrunchedCompressionChanged || compressionQualityChanged)
{
for (var i = 0; i < platformSettings.Count; ++i)
{
if (sizeChanged)
{
platformSettings[i].maxTextureSize = newSize;
}
if (compressionChanged)
{
platformSettings[i].textureCompression = newCompression;
}
if (useCrunchedCompressionChanged)
{
platformSettings[i].crunchedCompression = newUseCrunchedCompression;
}
if (compressionQualityChanged)
{
platformSettings[i].compressionQuality = newCompressionQuality;
}
}
return(true);
}
else
{
return(false);
}
}
