static Shader GetShaderFromProfile(MaterialQuality profile)
{
Shader sh;
switch (profile)
{
case MaterialQuality.Mobile:
sh = MobileShader;
break;
case MaterialQuality.Optimized:
sh = OptimizedShader;
break;
case MaterialQuality.HighEnd:
sh = ComplexShader;
break;
default:
sh = ComplexShader;
break;
}
return(sh);
}
public static void DuplicateMatsFromScene(MaterialQuality profile)
{
if (GUILayout.Button("Duplicate Mats"))
{
NeoFurAsset[] assets = GetNeoFurAssetsInCurrentScene();
for (int i = 0; i < assets.Length; ++i)
{
if (assets == null)
{
continue;
}
EditorUtility.DisplayProgressBar("Duplicating Materials", "Copying: " + i +
" of " + assets.Length, (float)i / (float)assets.Length);
Material m = assets[i].data.furryMat;
if (m == null)
{
continue;
}
DuplicateMaterialAsset(
GetUniqueAssetPathNameInCurrentFolder(m.name),
m, profile);
}
EditorUtility.ClearProgressBar();
}
}
// experimental features that try use partitional optimization (you may change it in inspector if water object selected, or here runtime)
public void SetMaterialQuality(MaterialQuality QualityAmount)
{
if (compiler.BufferResolution == (int)QualityAmount)
{
return;
}
compiler.BufferResolution = (int)QualityAmount;
}
public Material GetFor(MaterialQuality quality)
{
switch (quality)
{
case MaterialQuality.Low: return(new Material(0.1f, 10));
case MaterialQuality.Medium: return(new Material(0.2f, 20));
case MaterialQuality.High: return(new Material(0.2f, 40));
}
throw new Exception("Unknown material quality " + quality);
}
/// <summary>
/// Returns the index (in the MaterialQuality enum) of the first available level.
/// </summary>
/// <param name="level">MaterialQuality bitfield.</param>
/// <returns>The index of the first available level.</returns>
public static int ToFirstIndex(this MaterialQuality level)
{
for (var i = 0; i < KeywordNames.Length; ++i)
{
if ((level & (MaterialQuality)(1 << i)) != 0)
{
return(i);
}
}
return(-1);
}
/// <summary>
/// Returns the highest available quality level in a MaterialQuality bitfield.
/// </summary>
/// <param name="levels">Input MaterialQuality bitfield.</param>
/// <returns>The highest available quality level.</returns>
public static MaterialQuality GetHighestQuality(this MaterialQuality levels)
{
for (var i = Keywords.Length - 1; i >= 0; --i)
{
var level = (MaterialQuality)(1 << i);
if ((levels & level) != 0)
{
return(level);
}
}
return(0);
}
/// <summary>
/// Set the global keyword for the provided MaterialQuality.
/// </summary>
/// <param name="level">MaterialQuality level to set the keyword for.</param>
public static void SetGlobalShaderKeywords(this MaterialQuality level)
{
for (var i = 0; i < KeywordNames.Length; ++i)
{
if ((level & (MaterialQuality)(1 << i)) != 0)
{
Shader.EnableKeyword(KeywordNames[i]);
}
else
{
Shader.DisableKeyword(KeywordNames[i]);
}
}
}
/// <summary>
/// Set the global keyword for the provided MaterialQuality.
/// </summary>
/// <param name="level">MaterialQuality level to set the keyword for.</param>
/// <param name="cmd">Command Buffer used to setup the keyword.</param>
public static void SetGlobalShaderKeywords(this MaterialQuality level, CommandBuffer cmd)
{
for (var i = 0; i < KeywordNames.Length; ++i)
{
if ((level & (MaterialQuality)(1 << i)) != 0)
{
cmd.EnableShaderKeyword(KeywordNames[i]);
}
else
{
cmd.DisableShaderKeyword(KeywordNames[i]);
}
}
}
public static void DoBatch(string batchText, MaterialQuality batchProfile)
{
string[] names = batchText.Split(new char[] { ',', '\n' });
for (int i = 0; i < names.Length; ++i)
{
string name = names[i];
if (!string.IsNullOrEmpty(name))
{
CreateMaterialAsset(GetUniqueAssetPathNameInCurrentFolder(name),
batchProfile);
}
}
}
public static Material CreateMaterialAsset(string fileName, MaterialQuality profile)
{
Shader s = GetShaderFromProfile(profile);
if (!s)
{
Debug.LogErrorFormat("NeoFur: Trying to make {0} mat but shader could not be found.", profile.ToString());
return(null);
}
Material m = new Material(s);
CreateMaterialAsset(fileName, m);
return(m);
}
public static MaterialQualityMode Into(this MaterialQuality quality)
{
if (quality == (MaterialQuality)0)
{
return(MaterialQualityMode.FromQualitySettings);
}
switch (quality)
{
case MaterialQuality.High: return(MaterialQualityMode.High);
case MaterialQuality.Medium: return(MaterialQualityMode.Medium);
case MaterialQuality.Low: return(MaterialQualityMode.Low);
default: throw new ArgumentOutOfRangeException(nameof(quality));
}
}
/// <summary>
/// Returns the closest available quality level in a MaterialQuality bitfield.
/// </summary>
/// <param name="availableLevels">Available MaterialQuality bitfield.</param>
/// <param name="requestedLevel">Input MaterialQuality level.</param>
/// <returns>The closest available quality level.</returns>
public static MaterialQuality GetClosestQuality(this MaterialQuality availableLevels, MaterialQuality requestedLevel)
{
// Special fallback when there are no available quality levels. Needs to match in the shader stripping code
if (availableLevels == 0)
{
return(MaterialQuality.Low);
}
// First we want to find the closest available quality level below the requested one.
int requestedLevelIndex = ToFirstIndex(requestedLevel);
MaterialQuality chosenQuality = (MaterialQuality)0;
for (int i = requestedLevelIndex; i >= 0; --i)
{
var level = FromIndex(i);
if ((level & availableLevels) != 0)
{
chosenQuality = level;
break;
}
}
if (chosenQuality != 0)
{
return(chosenQuality);
}
// If none is found then we fallback to the closest above.
for (var i = requestedLevelIndex + 1; i < Keywords.Length; ++i)
{
var level = FromIndex(i);
var diff = Math.Abs(requestedLevel - level);
if ((level & availableLevels) != 0)
{
chosenQuality = level;
break;
}
}
Debug.Assert(chosenQuality != 0);
return(chosenQuality);
}
public static Material DuplicateMaterialAsset(string fileName, Material mat,
MaterialQuality profile = MaterialQuality.HighEnd)
{
Shader s = GetShaderFromProfile(profile);
if (!s)
{
Debug.LogErrorFormat("NeoFur: Trying to duplicate {0} mat but shader could not be found.", profile.ToString());
return(null);
}
Material m = new Material(mat);
if (s != null)
{
m.shader = s;
}
CreateMaterialAsset(fileName, m);
return(m);
}
internal static extern void Texture_SetMipsToSkip(IntPtr handle, MaterialQuality quality, int toSkip);
public Material(MaterialQuality quality)
{
Cost = storageMap[quality].Item1;
Value = storageMap[quality].Item2;
}
/// <summary>
/// Set technique.
/// </summary>
public void SetTechnique(uint index, Technique tech, MaterialQuality qualityLevel = MaterialQuality.Low, float lodDistance = 0f)
{
Runtime.ValidateRefCounted(this);
Material_SetTechnique(handle, index, (object)tech == null ? IntPtr.Zero : tech.Handle, qualityLevel, lodDistance);
}
/// <summary>
/// Return mip levels to skip on a quality setting when loading.
/// </summary>
public int GetMipsToSkip(MaterialQuality quality)
{
Runtime.ValidateRefCounted(this);
return(Texture_GetMipsToSkip(handle, quality));
}
internal static extern int Texture_GetMipsToSkip(IntPtr handle, MaterialQuality quality);
/// <summary>
/// Set mip levels to skip on a quality setting when loading. Ensures higher quality levels do not skip more.
/// </summary>
public void SetMipsToSkip(MaterialQuality quality, int toSkip)
{
Runtime.ValidateRefCounted(this);
Texture_SetMipsToSkip(handle, quality, toSkip);
}
internal static extern void Material_SetTechnique(IntPtr handle, uint index, IntPtr tech, MaterialQuality qualityLevel, float lodDistance);
