Unity3D - Don't compile if package name doesn't exist

Question

Is it possible to "gray out" the code if it doesn't exist like we do in Platform Dependent compilation (ex: #If UNITY_EDITOR)?

For example I don't want the compiler to complain if the code doesn't exist in the project. Specifically, I want to "hide" "GoogleMobileAds.Api;" package, which I don't have in the project, but it may be in the future.

Answer 1

Preprocessors are not an invention of Unity but is a c# thing.

If there are no specific defines listed in the Platform dependent compilation first make sure that your packages don't bring their own custom defines. Photon PUN e.g. actually does bring own defines like PHOTON_UNITY_NETWORKING, PUN_2_OR_NEWER, etc. But that's totally up to the providers of such libraries.

You can see/check this in the Edit -> Project Settings -> Player Settings -> Other Settings -> Scripting Define Symbols

Scripting Define Symbols
Set custom compilation flags. For more details, see the documentation on Platform dependent compilation.

Then you can just invent your own ones and add them to your code like e.g. USE_GOOGLE, USE_FIREBASE, etc

#if USE_GOOGLE
    // some Google API related stuff
#endif

and later once you actually have according package in your project add these defines to the Scripting Define Symbols mentioned above.

---

If you know the full qualified assembly name of one type contained in the optional package you are looking for you can use e.g.

[assembly: OptionalDependency("Namespace.SubNameSpace.TypeName", "YOUR_DEFINE_SYMBOL_HERE")]

which is well hidden in Unity.XRTools.Utils!

This will internally on compile time check if the type Namespace.SubNameSpace.TypeName exists and if so define YOUR_DEFINE_SYMBOL_HERE so you can again in your code wrap the optional stuff in

#if YOUR_DEFINE_SYMBOL_HERE
    ...
#else
    ...
#endif

---

Alternative

For packages you own/implemen yourself there is a way to do this kind of automatically I used in the past. The following script as soon as it exists in a project it automatically adds the given define to the PlayerSettings if it doesn't exists yet

#if !USE_GOOGLE
public static class UseGoogleDefineSetter
{
    const string DEFINE = "USE_GOOGLE";

    [InitializeOnLoadMethod]
    private void Init()
    {
        // Get current defines
        var currentDefinesString = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
        // Split at ;
        var defines = currentDefinesString.Split(';').ToList();
        // check if defines already exist given define
        if (!defines.Contains(DEFINE))
        {
            // if not add it at the end with a leading ; separator
            currentDefinesString += $";{DEFINE}";

            // write the new defines back to the PlayerSettings
            // This will cause a recompilation of your scripts
            PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, currentDefinesString);
        }
    }
}
#endif

---

Update Unity 2020+

The method was semi replaced by a better one operating on a list/array instead of an entire string which is expensive. And in the newest version also the build pipeline slightly changed.

So in newer Unity versions I would rather use something like e.g. (assuming 2020 is the oldest version you want to support/use)

#if !USE_GOOGLE
public static class UseGoogleDefineSetter
{
    const string DEFINE = "USE_GOOGLE";

    [InitializeOnLoadMethod]
    private void Init()
    {
        EditorUtils.AddScriptingSymbol(DEFINE);
    }
}
#endif

and to make it easy and general

public static class EditorUtils
{
#if UNITY_2021_2_OR_NEWER
    private static NamedBuildTarget GetActiveNamedBuildTarget()
    {
        var buildTargetGroup = GetActiveBuildTargetGroup();
        var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(buildTargetGroup);

        return namedBuildTarget;
    }
#endif

    private static BuildTargetGroup GetActiveBuildTargetGroup()
    {
        var buildTarget = EditorUserBuildSettings.activeBuildTarget;
        var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget);

        return buildTargetGroup;
    }

    public static void AddScriptingSymbol(string define)
    {
#if UNITY_2021_2_OR_NEWER
        var namedBuildTarget = GetActiveNamedBuildTarget();
        PlayerSettings.GetScriptingDefineSymbols(namedBuildTarget, out var defines);
#else
        var buildTargetGroup = GetActiveBuildTargetGroup();
        PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup, out var defines);
#endif

        var defineList = defines.ToList();

        if (!defineList.Contains(define))
        {
            defineList.Add(define);
        }

#if UNITY_2021_2_OR_NEWER
        PlayerSettings.SetScriptingDefineSymbols(namedBuildTarget, defineList.ToArray());
#else
        PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, defineList.ToArray());
#endif
    }
}

Both scripts go of course either in a folder called Editor and/or in an assembly only compiled for the Unity Editor or need to be wrapped additionally in #if UNITY_EDITOR