Addressables support

[Artein]

Question:
Is there any option to specify a scene that is a part of Addressable?

My case:
I have a scene that is part of Addressable and thus is not specified in Build Settings. But I need to specify it to load. Unfortunately, Addressable provides two ways to handle that:

• Specifying scene name (eg, using string)
• Selecting an asset (eg. using AssetReference)

Both are not convenient ways to work with scenes.

My current workaround:

// based on Eflatun.SceneReference
    [Serializable]
    public class AssetReferenceScene : AssetReference
    {
        // GUID hex of an invalid asset contains all zeros. A GUID hex has 32 chars.
        private const string AllZeroGuidHex = "00000000000000000000000000000000";
        
        /// <summary>
        /// Construct a new AssetReference object.
        /// </summary>
        /// <param name="guid">The guid of the asset.</param>
        public AssetReferenceScene(string guid) : base(guid)
        {
        }
        
        public string Name => System.IO.Path.GetFileNameWithoutExtension(Path);

        public string Path
        {
            get
            {
                if (!HasValue)
                {
                    throw new InvalidOperationException($"AssetReferenceScene has no value");
                }

                if (!SceneGuidToPathMapProvider.SceneGuidToPathMap.TryGetValue(AssetGUID, out var scenePath))
                {
                    throw new InvalidOperationException($"Didn't find scene (guid: {AssetGUID}) in SceneGuidToPathMap");
                }

                return scenePath;
            }
        }

        /// <summary>
        /// Is this <see cref="SceneReference"/> assigned something?
        /// </summary>
        /// <remarks>
        /// Only check this property if you need partial validations, as this property alone does not communicate whether this <see cref="SceneReference"/> is absolutely safe to use.<p/>
        /// If you only need to check if it is completely safe to use a <see cref="SceneReference"/> without knowing where exactly the problem is, then only check <see cref="IsSafeToUse"/> instead. Checking only <see cref="IsSafeToUse"/> is sufficient for the majority of the use cases.
        /// </remarks>
        /// <seealso cref="IsInSceneGuidToPathMap"/>
        /// <seealso cref="IsInBuildAndEnabled"/>
        /// <seealso cref="IsSafeToUse"/>
        public bool HasValue
        {
            get
            {
                if (!IsValidGuidHex(AssetGUID))
                {
                    // internal exceptions should not be documented as part of the public API
                    throw new InvalidOperationException($"AssetReferenceScene GUID is not valid");
                }

                return AssetGUID != AllZeroGuidHex;
            }
        }

#if UNITY_EDITOR
        /// <summary>
        /// Type-specific override of parent editorAsset.  Used by the editor to represent the asset referenced.
        /// </summary>
        public new UnityEditor.SceneAsset editorAsset => (UnityEditor.SceneAsset)base.editorAsset;
#endif

        /// <inheritdoc/>
        public override bool ValidateAsset(Object obj)
        {
#if UNITY_EDITOR
            var type = obj.GetType();
            return typeof(UnityEditor.SceneAsset).IsAssignableFrom(type);
#else
        return false;
#endif
        }

        /// <inheritdoc/>
        public override bool ValidateAsset(string path)
        {
#if UNITY_EDITOR
            var type = UnityEditor.AssetDatabase.GetMainAssetTypeAtPath(path);
            return typeof(UnityEditor.SceneAsset).IsAssignableFrom(type);
#else
        return false;
#endif
        }

        public static bool IsValidGuidHex(string guidHex) => guidHex.Length == 32 && guidHex.ToUpper().All("0123456789ABCDEF".Contains);
    }

[starikcetin]

Hello,

I don't quite understand why AssetReference is not enough for you. It is the official Unity way of referencing addressable assets and scenes.

[Artein]

Hi @starikcetin,

Thank you for answering this question.

Actually, it is pretty strange to receive a such answer, especially in such kind of repo.
To paraphrase what you are saying related to this repo: "why do you need to assign scenes via references, cause there is an official Unity way to do that via strings".

For me, it is needed to filter out assets that are not scenes. Such assets like scenes must be loaded in a special way via addressable and have separate API calls for that.

So, such functionality might be a good addition to this repository.

[starikcetin]

It is not trivial to deal with Addressables and still keep the promise of being 100% robust, but I will try a couple of things. In the meantime, my recommendation is to stick with AssetReferences, or to write an inspector wrapper class which only accepts scene assets (using a property drawer).

[Artein]

Thank you @starikcetin .
I asked similar question on related sub-forum. Hope you might find it useful as well (https://forum.unity.com/threads/assetreferencescene.1381449/)

[starikcetin]

Update: I am currently working on support for addressable scenes. No ETA yet. Please track the progress on issue #6.

[starikcetin]

Implemented in #47. Will be included in next release.

[starikcetin]

Included in 3.0.0.