Files
StudyCase/Assets/BOXOPHOBIC/Utils/Scripts/Utility/Utility.cs

1302 lines
40 KiB
C#
Raw Normal View History

2025-11-24 21:29:46 +08:00
// Cristian Pop - https://boxophobic.com/
using System.Globalization;
using System.IO;
using System.Linq;
#if UNITY_EDITOR
using UnityEditor;
#endif
using UnityEngine;
using UnityEngine.Rendering;
namespace Boxophobic.Utility
{
public static class BoxoUtils
{
public static ProjectData GetProjectData()
{
const string minimumVersionFor2021_3 = "2021.3.35";
const string minimumVersionFor2022_3 = "2022.3.18";
const string minimumVersionFor6000_0 = "6000.0.23";
const string minimumVersionFor6000_1 = "6000.1.0";
const string minimumVersionFor6000_2 = "6000.2.0";
const string minimumVersionFor6000_3 = "6000.3.0";
const string minimumVersionFor6000_4 = "6000.4.0";
var projectData = new ProjectData();
string pipeline = "Standard";
if (GraphicsSettings.defaultRenderPipeline != null)
{
if (GraphicsSettings.defaultRenderPipeline.GetType().ToString().Contains("Universal"))
{
pipeline = "Universal";
}
if (GraphicsSettings.defaultRenderPipeline.GetType().ToString().Contains("HD"))
{
pipeline = "High Definition";
}
}
if (QualitySettings.renderPipeline != null)
{
if (QualitySettings.renderPipeline.GetType().ToString().Contains("Universal"))
{
pipeline = "Universal";
}
if (QualitySettings.renderPipeline.GetType().ToString().Contains("HD"))
{
pipeline = "High Definition";
}
}
projectData.pipeline = pipeline;
var version = Application.unityVersion;
if (version.Contains("a") || version.Contains("b"))
{
projectData.isAlphaOrBetaRelease = true;
}
version = version.Replace("f", "x").Replace("a", "x").Replace("b", "x");
if (pipeline != "Standard")
{
var versionSplit = version.Split(".");
var version0 = int.Parse(versionSplit[0], CultureInfo.InvariantCulture);
var version1 = int.Parse(versionSplit[1], CultureInfo.InvariantCulture);
var version2Split = versionSplit[2].Split("x");
var version2 = int.Parse(version2Split[0], CultureInfo.InvariantCulture);
//if (version0 == 2021)
//{
// var minimumSplit = minimumVersionFor2021_3.Split(".");
// var minimum2 = int.Parse(minimumSplit[2], CultureInfo.InvariantCulture);
// if (version1 != 3)
// {
// projectData.isSupported = false;
// }
// else
// {
// if (version2 < minimum2)
// {
// projectData.isSupported = false;
// }
// }
// projectData.package = "2021.3+";
//}
if (version0 == 2022)
{
var minimumSplit = minimumVersionFor2022_3.Split(".");
var minimum2 = int.Parse(minimumSplit[2], CultureInfo.InvariantCulture);
if (version1 != 3)
{
projectData.isSupported = false;
}
else
{
if (version2 < minimum2)
{
projectData.isSupported = false;
}
}
projectData.package = "2022.3+";
}
if (version0 == 6000)
{
if (version1 == 0)
{
var minimumSplit = minimumVersionFor6000_0.Split(".");
var minimum2 = int.Parse(minimumSplit[2], CultureInfo.InvariantCulture);
if (version2 < minimum2)
{
projectData.isSupported = false;
}
projectData.package = "6000.0+";
}
if (version1 == 1)
{
var minimumSplit = minimumVersionFor6000_1.Split(".");
var minimum2 = int.Parse(minimumSplit[2], CultureInfo.InvariantCulture);
if (version2 < minimum2)
{
projectData.isSupported = false;
}
projectData.isTechRelease = true;
projectData.package = "6000.1+";
}
if (version1 == 2)
{
var minimumSplit = minimumVersionFor6000_2.Split(".");
var minimum2 = int.Parse(minimumSplit[2], CultureInfo.InvariantCulture);
if (version2 < minimum2)
{
projectData.isSupported = false;
}
projectData.isTechRelease = true;
projectData.package = "6000.2+";
}
if (version1 == 3)
{
var minimumSplit = minimumVersionFor6000_2.Split(".");
var minimum2 = int.Parse(minimumSplit[2], CultureInfo.InvariantCulture);
if (version2 < minimum2)
{
projectData.isSupported = false;
}
projectData.package = "6000.3+";
}
if (version1 == 4)
{
var minimumSplit = minimumVersionFor6000_2.Split(".");
var minimum2 = int.Parse(minimumSplit[2], CultureInfo.InvariantCulture);
if (version2 < minimum2)
{
projectData.isSupported = false;
}
projectData.isTechRelease = true;
projectData.package = "6000.4+";
}
}
var minimum = minimumVersionFor2021_3;
if (version0 == 2022)
{
minimum = minimumVersionFor2022_3;
}
if (version0 == 6000)
{
minimum = minimumVersionFor6000_0;
}
if (version0 == 6001)
{
minimum = minimumVersionFor6000_1;
}
if (version0 == 6002)
{
minimum = minimumVersionFor6000_2;
}
if (version0 == 6003)
{
minimum = minimumVersionFor6000_3;
}
if (version0 == 6004)
{
minimum = minimumVersionFor6000_4;
}
projectData.minimum = minimum;
}
return projectData;
}
public static string GetProjectPipeline()
{
string pipeline = "Standard";
if (GraphicsSettings.defaultRenderPipeline != null)
{
if (GraphicsSettings.defaultRenderPipeline.GetType().ToString().Contains("Universal"))
{
pipeline = "Universal";
}
if (GraphicsSettings.defaultRenderPipeline.GetType().ToString().Contains("HD"))
{
pipeline = "High Definition";
}
}
if (QualitySettings.renderPipeline != null)
{
if (QualitySettings.renderPipeline.GetType().ToString().Contains("Universal"))
{
pipeline = "Universal";
}
if (QualitySettings.renderPipeline.GetType().ToString().Contains("HD"))
{
pipeline = "High Definition";
}
}
return pipeline;
}
// Material Utils
public static void SetMaterialBool(Material material, string valueProp, string internalProp)
{
if (material.HasProperty(valueProp))
{
var value = material.GetFloat(valueProp);
if (value > 0)
{
material.SetInt(internalProp, 1);
}
else
{
material.SetInt(internalProp, 0);
}
}
}
public static void SetMaterialInt(Material material, string valueProp, string internalProp)
{
if (material.HasProperty(valueProp))
{
material.SetInt(internalProp, material.GetInt(valueProp));
}
}
public static void SetMaterialFloat(Material material, string valueProp, string internalProp)
{
if (material.HasProperty(valueProp))
{
material.SetFloat(internalProp, material.GetFloat(valueProp));
}
}
public static void SetMaterialVector(Material material, string valueProp, string internalProp)
{
if (material.HasProperty(valueProp))
{
material.SetVector(internalProp, material.GetVector(valueProp));
}
}
public static void SetMaterialTexture(Material material, string valueProp, string internalProp)
{
if (material.HasProperty(valueProp))
{
material.SetTexture(internalProp, material.GetTexture(valueProp));
}
}
public static void SetMaterialCoords(Material material, string modeProp, string valueProp, string internalProp)
{
if (material.HasProperty(modeProp) && material.HasProperty(valueProp))
{
var mode = material.GetInt(modeProp);
var value = material.GetVector(valueProp);
if (mode == 0)
{
material.SetVector(internalProp, value);
}
else if (mode == 1)
{
material.SetVector(internalProp, new Vector4(1 / value.x, 1 / value.y, value.z, value.w));
}
}
}
public static void SetMaterialBounds(Material material, string modeProp, string valueProp, string internalProp)
{
var offset = 0.0f;
if (material.HasProperty(modeProp) && material.HasProperty(valueProp))
{
var mode = material.GetInt(modeProp);
if (mode == 1)
{
offset = 0.5f;
}
var value = material.GetVector(valueProp);
var scale = new Vector2(1 / value.z, 1 / value.w);
var pos = new Vector2(value.x * scale.x - offset, value.y * scale.y - offset) * -1;
material.SetVector(internalProp, new Vector4(scale.x, scale.y, pos.x, pos.y));
}
}
public static void SetMaterialOptions(Material material, string modeProp, string valueProp)
{
if (material.HasProperty(modeProp))
{
var mode = material.GetInt(modeProp);
if (mode == 0)
{
material.SetVector(valueProp, new Vector4(1, 0, 0, 0));
}
else if (mode == 1)
{
material.SetVector(valueProp, new Vector4(0, 1, 0, 0));
}
else if (mode == 2)
{
material.SetVector(valueProp, new Vector4(0, 0, 1, 0));
}
else if (mode == 3)
{
material.SetVector(valueProp, new Vector4(0, 0, 0, 1));
}
}
}
public static void SetMaterialOptions(Material material, string modeProp, string valuePropA, string valuePropB)
{
if (material.HasProperty(modeProp))
{
var mode = material.GetInt(modeProp);
if (mode == 0)
{
material.SetVector(valuePropA, new Vector4(1, 0, 0, 0));
material.SetVector(valuePropB, Vector4.zero);
}
else if (mode == 1)
{
material.SetVector(valuePropA, new Vector4(0, 1, 0, 0));
material.SetVector(valuePropB, Vector4.zero);
}
else if (mode == 2)
{
material.SetVector(valuePropA, new Vector4(0, 0, 1, 0));
material.SetVector(valuePropB, Vector4.zero);
}
else if (mode == 3)
{
material.SetVector(valuePropA, new Vector4(0, 0, 0, 1));
material.SetVector(valuePropB, Vector4.zero);
}
else if (mode == 4)
{
material.SetVector(valuePropA, Vector4.zero);
material.SetVector(valuePropB, new Vector4(1, 0, 0, 0));
}
else if (mode == 5)
{
material.SetVector(valuePropA, Vector4.zero);
material.SetVector(valuePropB, new Vector4(0, 1, 0, 0));
}
else if (mode == 6)
{
material.SetVector(valuePropA, Vector4.zero);
material.SetVector(valuePropB, new Vector4(0, 0, 1, 0));
}
else if (mode == 7)
{
material.SetVector(valuePropA, Vector4.zero);
material.SetVector(valuePropB, new Vector4(0, 0, 0, 1));
}
}
}
public static void SetMaterialBackface(Material material, string modeProp, string valueProp)
{
if (material.HasProperty(modeProp))
{
// None 0 / Flip 1 / Mirror 2
var mode = material.GetInt(modeProp);
if (mode == 0)
{
material.SetVector(valueProp, new Vector4(1, 1, 1, 0));
}
else if (mode == 1)
{
material.SetVector(valueProp, new Vector4(-1, -1, -1, 0));
}
else if (mode == 2)
{
material.SetVector(valueProp, new Vector4(1, 1, -1, 0));
}
}
}
public static void SetMaterialBackfaceLegacy(Material material, string modeProp, string valueProp)
{
if (material.HasProperty(modeProp))
{
// Flip 0 / Mirror 1 / None 2
var mode = material.GetInt(modeProp);
if (mode == 0)
{
material.SetVector(valueProp, new Vector4(-1, -1, -1, 0));
}
else if (mode == 1)
{
material.SetVector(valueProp, new Vector4(1, 1, -1, 0));
}
else if (mode == 2)
{
material.SetVector(valueProp, new Vector4(1, 1, 1, 0));
}
}
}
public static void SetMaterialReciprocal(Material material, string valueProp)
{
if (material.HasProperty(valueProp))
{
var value = material.GetVector(valueProp);
material.SetVector(valueProp, new Vector4(value.x, value.y, 1 / (value.y - value.x), value.w));
}
}
public static void SetMaterialKeyword(Material material, string keyword, bool enable)
{
if (enable)
{
material.EnableKeyword(keyword);
}
else
{
material.DisableKeyword(keyword);
}
}
public static void SetMaterialKeyword(Material material, string property, string keyword)
{
if (material.HasFloat(property))
{
var mode = material.GetFloat(property);
if (mode == 0)
{
material.DisableKeyword(keyword);
}
else
{
material.EnableKeyword(keyword);
}
}
}
public static void SetMaterialKeyword(Material material, string property, string[] keywords)
{
if (material.HasFloat(property))
{
var mode = material.GetFloat(property);
for (int i = 0; i < keywords.Length; i++)
{
if (i == mode)
{
material.EnableKeyword(keywords[i]);
}
else
{
material.DisableKeyword(keywords[i]);
}
}
}
}
public static void SetMaterialKeyword(Material material, string parent, string property, string keyword)
{
if (material.HasFloat(parent) && material.HasFloat(property))
{
var parentMode = material.GetFloat(parent);
if (parentMode > 0)
{
var propertyMode = material.GetFloat(property);
if (propertyMode == 0)
{
material.DisableKeyword(keyword);
}
else
{
material.EnableKeyword(keyword);
}
}
else
{
material.DisableKeyword(keyword);
}
}
}
public static void SetMaterialKeyword(Material material, string parent, string property, string[] keywords)
{
if (material.HasFloat(parent) && material.HasFloat(property))
{
var parentMode = material.GetFloat(parent);
if (parentMode > 0)
{
var propertyMode = material.GetFloat(property);
for (int i = 0; i < keywords.Length; i++)
{
if (i == propertyMode)
{
material.EnableKeyword(keywords[i]);
}
else
{
material.DisableKeyword(keywords[i]);
}
}
}
else
{
for (int i = 0; i < keywords.Length; i++)
{
material.DisableKeyword(keywords[i]);
}
}
}
}
public static void SetMaterialKeyword(Material material, bool allParentsOn, string[] parents, string property, string keyword)
{
bool parentsMode = false;
float propertyMode = 0;
if (allParentsOn)
{
int enableCount = 0;
for (int i = 0; i < parents.Length; i++)
{
var parent = parents[i];
if (material.HasProperty(parent))
{
if (material.GetFloat(parent) > 0)
{
enableCount++;
}
}
}
if (parents.Length == enableCount)
{
parentsMode = true;
}
}
else
{
float enableFloat = 0;
for (int i = 0; i < parents.Length; i++)
{
var parent = parents[i];
if (material.HasProperty(parent))
{
enableFloat += material.GetFloat(parent);
}
}
if (enableFloat > 0)
{
parentsMode = true;
}
}
if (material.HasProperty(property))
{
propertyMode = material.GetFloat(property);
}
if (parentsMode && propertyMode > 0)
{
material.EnableKeyword(keyword);
}
else
{
material.DisableKeyword(keyword);
}
}
public static void SetMaterialKeyword(Material material, bool allParentsOn, string[] parents, string property, string[] keywords)
{
bool parentsMode = false;
if (allParentsOn)
{
int enableCount = 0;
for (int i = 0; i < parents.Length; i++)
{
var parent = parents[i];
if (material.HasProperty(parent))
{
if (material.GetFloat(parent) > 0)
{
enableCount++;
}
}
}
if (parents.Length == enableCount)
{
parentsMode = true;
}
}
else
{
float enableFloat = 0;
for (int i = 0; i < parents.Length; i++)
{
var parent = parents[i];
if (material.HasProperty(parent))
{
enableFloat += material.GetFloat(parent);
}
}
if (enableFloat > 0)
{
parentsMode = true;
}
}
if (material.HasFloat(property))
{
if (parentsMode)
{
var propertyMode = material.GetInt(property);
for (int i = 0; i < keywords.Length; i++)
{
if (i == propertyMode)
{
material.EnableKeyword(keywords[i]);
}
else
{
material.DisableKeyword(keywords[i]);
}
}
}
else
{
for (int i = 0; i < keywords.Length; i++)
{
material.DisableKeyword(keywords[i]);
}
}
}
}
public static void SetMaterialKeyword(Material material, bool allParentsOn, string[] properties, string keyword)
{
bool parentMode = false;
if (allParentsOn)
{
int enableCount = 0;
for (int i = 0; i < properties.Length; i++)
{
var property = properties[i];
if (material.HasProperty(property))
{
if (material.GetFloat(property) > 0)
{
enableCount++;
}
}
}
if (properties.Length == enableCount)
{
parentMode = true;
}
}
else
{
float enableFloat = 0;
for (int i = 0; i < properties.Length; i++)
{
var property = properties[i];
if (material.HasProperty(property))
{
enableFloat += material.GetFloat(property);
}
}
if (enableFloat > 0)
{
parentMode = true;
}
}
if (parentMode)
{
material.EnableKeyword(keyword);
}
else
{
material.DisableKeyword(keyword);
}
}
public static void SetMaterialKeywordInverted(Material material, string property, string keyword)
{
if (material.HasFloat(property))
{
var mode = material.GetFloat(property);
if (mode == 0)
{
material.EnableKeyword(keyword);
}
else
{
material.DisableKeyword(keyword);
}
}
}
public static void SetMaterialKeywordByTexture(Material material, string property, string keyword)
{
if (IsMaterialTextureUsed(material, property))
{
material.EnableKeyword(keyword);
}
else
{
material.DisableKeyword(keyword);
}
}
public static float GetMaterialFloat(Material material, string property, float defaultValue)
{
float value = defaultValue;
if (material.HasFloat(property))
{
value = material.GetFloat(property);
}
return value;
}
public static float GetMaterialFloat(Material material, string property)
{
return GetMaterialFloat(material, property, 0);
}
public static int GetMaterialInt(Material material, string property, int defaultValue)
{
int value = defaultValue;
if (material.HasFloat(property))
{
value = material.GetInt(property);
}
return value;
}
public static int GetMaterialInt(Material material, string property)
{
return GetMaterialInt(material, property, 0);
}
public static Texture GetMaterialTexture(Material material, string property)
{
Texture value = null;
if (material.HasTexture(property))
{
value = material.GetTexture(property);
}
return value;
}
public static bool IsMaterialTextureUsed(Material material, string property)
{
bool value = false;
if (material.HasTexture(property))
{
if (material.GetTexture(property) != null)
{
value = true;
}
}
return value;
}
// Math Utils
public static float MathRemap(float value, float minOld, float maxOld, float minNew, float maxNew)
{
return minNew + (value - minOld) * (maxNew - minNew) / (maxOld - minOld);
}
public static float MathRemap(float value, float minOld, float maxOld)
{
return (value - minOld) / (maxOld - minOld);
}
public static float MathVector2ToFloat(float x, float y)
{
Vector2 output;
output.x = Mathf.Floor(x * (2048 - 1));
output.y = Mathf.Floor(y * (2048 - 1));
return (output.x * 2048) + output.y;
}
public static Vector2 MathFloatFromVector2(float input)
{
Vector2 output;
output.y = input % 2048f;
output.x = Mathf.Floor(input / 2048f);
return output / (2048f - 1);
}
#if UNITY_EDITOR
public static float GetMaterialSerializedFloat(Material material, string internalName, float defaultValue)
{
float value = defaultValue;
if (EditorUtility.IsPersistent(material))
{
var so = new SerializedObject(material);
var itr = so.GetIterator();
while (itr.Next(true))
{
if (itr.displayName == internalName)
{
if (itr.hasChildren)
{
var itrC = itr.Copy();
itrC.Next(true); //Walk into child ("First")
itrC.Next(false); //Walk into sibling ("Second")
value = itrC.floatValue;
}
}
}
}
return value;
}
public static Vector4 GetMaterialSerializedVector(Material material, string internalName, Vector4 defaultValue)
{
Vector4 value = defaultValue;
if (EditorUtility.IsPersistent(material))
{
var so = new SerializedObject(material);
var itr = so.GetIterator();
while (itr.Next(true))
{
if (itr.displayName == internalName)
{
if (itr.hasChildren)
{
var itrC = itr.Copy();
itrC.Next(true); //Walk into child ("First")
itrC.Next(false); //Walk into sibling ("Second")
value = itrC.colorValue;
}
}
}
}
return value;
}
public static Vector4 GetMaterialSerializedVector(Material material, string internalNameMin, string internalNameMax, Vector4 defaultValue)
{
Vector4 value = defaultValue;
value.x = GetMaterialSerializedFloat(material, internalNameMin, 0);
value.y = GetMaterialSerializedFloat(material, internalNameMax, 1);
if (value.x > value.y)
{
value.w = 1;
}
return value;
}
public static Texture2D GetMaterialSerializedTexture(Material material, string internalName, Texture2D defaultValue)
{
Texture2D value = defaultValue;
if (EditorUtility.IsPersistent(material))
{
var so = new SerializedObject(material);
var itr = so.GetIterator();
while (itr.Next(true))
{
if (itr.displayName == internalName)
{
if (itr.hasChildren)
{
var itrC = itr.Copy();
itrC.Next(true); //Walk into child ("First")
itrC.Next(false); //Walk into sibling ("Second")
if (itrC.hasChildren)
{
var itrT = itrC.Copy();
itrT.Next(true); //Walk into child ("First")
value = (Texture2D)itrT.objectReferenceValue;
}
}
}
}
}
return value;
}
public static bool IsShaderGUIPropertyHidden(MaterialProperty property)
{
#if UNITY_6000_2_OR_NEWER
if (property.propertyFlags == UnityEngine.Rendering.ShaderPropertyFlags.HideInInspector)
#else
if (property.flags == MaterialProperty.PropFlags.HideInInspector)
#endif
{
return true;
}
else
{
return false;
}
}
public static bool IsShaderGUIPropertyTexture(MaterialProperty property)
{
#if UNITY_6000_2_OR_NEWER
if (property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Texture)
#else
if (property.type == MaterialProperty.PropType.Texture)
#endif
{
return true;
}
else
{
return false;
}
}
public static bool IsShaderGUIPropertyFloat(MaterialProperty property)
{
#if UNITY_6000_2_OR_NEWER
if (property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Float || property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Int || property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Range)
#else
if (property.type == MaterialProperty.PropType.Float || property.type == MaterialProperty.PropType.Int || property.type == MaterialProperty.PropType.Range)
#endif
{
return true;
}
else
{
return false;
}
}
public static bool IsShaderGUIPropertyVector(MaterialProperty property)
{
#if UNITY_6000_2_OR_NEWER
if (property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Vector || property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Color)
#else
if (property.type == MaterialProperty.PropType.Vector || property.type == MaterialProperty.PropType.Color)
#endif
{
return true;
}
else
{
return false;
}
}
public static int GetShaderPropertyCount(Shader shader)
{
#if UNITY_6000_2_OR_NEWER
return shader.GetPropertyCount();
#else
return ShaderUtil.GetPropertyCount(shader);
#endif
}
public static string GetShaderPropertyName(Shader shader, int index)
{
#if UNITY_6000_2_OR_NEWER
return shader.GetPropertyName(index);
#else
return ShaderUtil.GetPropertyName(shader, index);
#endif
}
public static ShaderPropertyType GetShaderPropertyType(Shader shader, int index)
{
#if UNITY_6000_2_OR_NEWER
return shader.GetPropertyType(index);
#else
return (ShaderPropertyType)ShaderUtil.GetPropertyType(shader, index);
#endif
}
public static string GetAssetFolder(string searchFile, string defaultPath)
{
var folder = FindAsset(searchFile);
folder = folder.Replace("/" + searchFile, "");
if (folder == "")
{
folder = defaultPath;
}
return folder;
}
public static string GetUserFolder()
{
if (!Directory.Exists(BoxoGlobals.userFolder))
{
string[] guids = AssetDatabase.FindAssets("t:DefaultAsset " + "BOXOPHOBIC+");
foreach (string guid in guids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
if (AssetDatabase.IsValidFolder(path) && Path.GetFileName(path) == "BOXOPHOBIC+")
{
BoxoGlobals.userFolder = path;
}
}
}
return BoxoGlobals.userFolder;
}
public static string[] FindAssets(string filter, bool sort)
{
var assetPaths = AssetDatabase.FindAssets("glob:\"" + filter + "\"");
if (sort)
{
assetPaths = assetPaths.OrderBy(f => new FileInfo(f).Name).ToArray();
}
for (int i = 0; i < assetPaths.Length; i++)
{
assetPaths[i] = AssetDatabase.GUIDToAssetPath(assetPaths[i]);
}
return assetPaths;
}
public static string FindAsset(string filter)
{
var assetPath = "";
var assetGUIDs = AssetDatabase.FindAssets("glob:\"" + filter + "\"");
if (assetGUIDs != null && assetGUIDs.Length > 0)
{
assetPath = AssetDatabase.GUIDToAssetPath(assetGUIDs[0]);
}
return assetPath;
}
public static void SetDefineSymbol(string symbol)
{
#if UNITY_2023_1_OR_NEWER
BuildTarget buildTarget = EditorUserBuildSettings.activeBuildTarget;
BuildTargetGroup targetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget);
var namedBuildTarget = UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(targetGroup);
var defineSymbols = PlayerSettings.GetScriptingDefineSymbols(namedBuildTarget);
#else
var defineSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
#endif
if (!defineSymbols.Contains(symbol))
{
defineSymbols += ";" + symbol + ";";
#if UNITY_2023_1_OR_NEWER
PlayerSettings.SetScriptingDefineSymbols(namedBuildTarget, defineSymbols);
#else
PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, defineSymbols);
#endif
}
}
public static void SetDefineSymbol(string symbol, string version)
{
#if UNITY_2023_1_OR_NEWER
BuildTarget buildTarget = EditorUserBuildSettings.activeBuildTarget;
BuildTargetGroup targetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget);
var namedBuildTarget = UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(targetGroup);
var defineSymbols = PlayerSettings.GetScriptingDefineSymbols(namedBuildTarget);
#else
var defineSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
#endif
var defineSymbolsSplit = defineSymbols.Split(";");
var newDefineSymbols = "";
var versionFormat = symbol + "_V";
var versionSymbol = symbol + "_V" + version;
for (int i = 0; i < defineSymbolsSplit.Length; i++)
{
var define = defineSymbolsSplit[i];
if (define.Contains(versionFormat))
{
defineSymbolsSplit[i] = versionSymbol;
}
newDefineSymbols = newDefineSymbols + defineSymbolsSplit[i] + ";";
}
if (!newDefineSymbols.Contains(symbol))
{
newDefineSymbols = newDefineSymbols + symbol + ";";
}
if (!newDefineSymbols.Contains(versionFormat))
{
newDefineSymbols = newDefineSymbols + versionSymbol + ";";
}
#if UNITY_2023_1_OR_NEWER
PlayerSettings.SetScriptingDefineSymbols(namedBuildTarget, newDefineSymbols);
#else
PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, newDefineSymbols);
#endif
}
public static bool HasDefineSymbol(string symbol)
{
bool hasSymbol = false;
#if UNITY_2023_1_OR_NEWER
BuildTarget buildTarget = EditorUserBuildSettings.activeBuildTarget;
BuildTargetGroup targetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget);
var namedBuildTarget = UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(targetGroup);
var defineSymbols = PlayerSettings.GetScriptingDefineSymbols(namedBuildTarget);
#else
var defineSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
#endif
if (defineSymbols.Contains(symbol))
{
hasSymbol = true;
}
return hasSymbol;
}
#endif
//Misc Utils
public static void DestryObject(UnityEngine.Object objectToDestory)
{
#if UNITY_EDITOR
if (Application.isPlaying)
{
UnityEngine.Object.Destroy(objectToDestory);
}
else
{
UnityEngine.Object.DestroyImmediate(objectToDestory);
}
#else
UnityEngine.Object.Destroy(objectToDestory);
#endif
}
public static void DisableServerExecution()
{
#if UNITY_SERVER
return;
#endif
}
public class BoxoGlobals
{
public static string userFolder = "Assets/BOXOPHOBIC+";
}
[System.Serializable]
public class ProjectData
{
public string pipeline = "";
public string minimum = "";
public string package = "";
public bool isSupported = true;
public bool isTechRelease = false;
public bool isAlphaOrBetaRelease = false;
public ProjectData()
{
}
}
}
}