the packages mentality was a mistake at this time, pushing to keep ev…

…erything in sync

Basis/Packages/com.basis.addressables/AddressableLoadResource.cs

@@ -0,0 +1,66 @@
+using Basis.Scripts.Addressable_Driver.DebugError;
+using Basis.Scripts.Addressable_Driver.Enums;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.Events;
+using UnityEngine.ResourceManagement.AsyncOperations;
+using UnityEngine.ResourceManagement.ResourceLocations;
+using UnityEngine.SceneManagement;
+namespace Basis.Scripts.Addressable_Driver
+{
+    [System.Serializable]
+    public class AddressableLoadResourceBase
+    {
+        public string CatalogPath;
+        public string Key;
+        public AddressableLoadResourceType ResourceType = AddressableLoadResourceType.Generic;
+        public AddressableExpectedResult ExpectedResult = AddressableExpectedResult.SingleItem;
+        public IList<IResourceLocation> ResourceLocationHandles;
+        public IList<AsyncOperationHandle> Handles = new List<AsyncOperationHandle>();
+        public UnityEvent<string> OnLoadFailure = new UnityEvent<string>();
+        public UnityEvent<AddressableLoadResourceBase> OnLoaded = new UnityEvent<AddressableLoadResourceBase>();
+        public float LoadPercentage = 0;
+        public bool IsLoading = false;
+        public bool IsBuiltIn = true;
+        public AddressableLoadResourceBase(string key, AddressableExpectedResult expectedResult)
+        {
+            Key = key;
+            ExpectedResult = expectedResult;
+        }
+    }
+    public class AddressableGenericResource : AddressableLoadResourceBase
+    {
+        public AddressableGenericResource(string key, AddressableExpectedResult expectedResult) : base(key, expectedResult)
+        {
+            ResourceType = AddressableLoadResourceType.Generic;
+        }
+
+        public AddressableGenericResource(AssetReference assetReference, AddressableExpectedResult expectedResult) : base(assetReference.RuntimeKeyIsValid() ? assetReference.RuntimeKey.ToString() : "Invalid", expectedResult)
+        {
+            if (!assetReference.RuntimeKeyIsValid())
+            {
+                Debug.Log("Construct Type is Other but Preset == Scene or Gameobject");
+            }
+        }
+
+        public AddressableGenericResource(string key, AddressableLoadResourceType resourceType, AddressableExpectedResult expectedResult) : base(key, expectedResult)
+        {
+            ResourceType = resourceType;
+        }
+    }
+
+    public class AddressableSceneResource : AddressableLoadResourceBase
+    {
+        public bool SetAsActiveScene = true;
+        public bool HasActiveSceneCallback = false;
+        public LoadSceneMode LoadSceneMode = LoadSceneMode.Additive;
+
+        public AddressableSceneResource(string key, bool setAsActiveScene, LoadSceneMode loadSceneMode) : base(key, AddressableExpectedResult.SingleItem)
+        {
+            ResourceType = AddressableLoadResourceType.Scene;
+            SetAsActiveScene = setAsActiveScene;
+            LoadSceneMode = loadSceneMode;
+        }
+    }
+}

Basis/Packages/com.basis.addressables/BasisAddressableDriver.asmdef

@@ -0,0 +1,19 @@
+{
+    "name": "BasisAddressableDriver",
+    "rootNamespace": "",
+    "references": [
+        "GUID:9e24947de15b9834991c9d8411ea37cf",
+        "GUID:84651a3751eca9349aac36a66bba901b",
+        "GUID:e0cd26848372d4e5c891c569017e11f1",
+        "GUID:b4ae365a73764ee478adc74cb89832fe"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Basis/Packages/com.basis.addressables/Debug/AddressableDebug.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Basis.Scripts.Addressable_Driver.DebugError
+{
+    public static class AddressableDebug
+    {
+        public static void DebugError(string message, AddressableLoadResourceBase loadStruct)
+        {
+            loadStruct.OnLoadFailure.Invoke(message);
+            Debug.LogError(message);
+        }
+    }
+}

Basis/Packages/com.basis.addressables/Enums/AddressableExpectedResult.cs

@@ -0,0 +1,7 @@
+namespace Basis.Scripts.Addressable_Driver.Enums
+{
+public enum AddressableExpectedResult
+{
+    IgnoreThisCheck, SingleItem, MulitpleItems
+}
+}

Basis/Packages/com.basis.addressables/Enums/AddressableLoadResourceType.cs

@@ -0,0 +1,8 @@
+namespace Basis.Scripts.Addressable_Driver.Enums
+{
+public enum AddressableLoadResourceType
+{
+    Generic,
+    Scene,
+}
+}

Basis/Packages/com.basis.addressables/Factory/AddressableLoadFactory.cs

@@ -0,0 +1,95 @@
+using Basis.Scripts.Addressable_Driver.DebugError;
+using Basis.Scripts.Addressable_Driver.Resource;
+using Basis.Scripts.Addressable_Driver.Validation;
+using System;
+using System.Threading.Tasks;
+using UnityEngine.AddressableAssets;
+namespace Basis.Scripts.Addressable_Driver.Factory
+{
+    /// <summary>
+    /// Factory class for loading addressable assets asynchronously.
+    /// </summary>
+    public static class AddressableLoadFactory
+    {
+        /// <summary>
+        /// Asynchronously loads an addressable asset.
+        /// </summary>
+        /// <param name="LoadRequest">The load request parameters.</param>
+        public static async Task<bool> LoadAddressableResourceAsync<T>(AddressableLoadResourceBase LoadRequest)
+        {
+            LoadRequest.IsLoading = true;
+            try
+            {
+                if (AddressableValidation.ValidateLoadResource(LoadRequest))
+                {
+                    // For safety, we never assume people are going to do the right thing.
+                    if (ReleaseResource(LoadRequest))
+                    {
+                        AddressableDebug.DebugError("Trying to load an addressable asset that was already loaded, resolving...", LoadRequest);
+                    }
+
+                    if (LoadRequest.IsBuiltIn)
+                    {
+                        LoadRequest.ResourceLocationHandles = await Addressables.LoadResourceLocationsAsync(LoadRequest.Key, typeof(T)).Task;
+                    }
+                    else
+                    {
+                        LoadRequest.ResourceLocationHandles = await AddressableRemoteLoader.LoadcatalogAndReturnIResourceLocation(LoadRequest.CatalogPath, LoadRequest.Key, typeof(T));
+                    }
+                    if (LoadRequest.ResourceLocationHandles != null)
+                    {
+                        if (LoadRequest.ResourceLocationHandles.Count == 0)
+                        {
+                            AddressableDebug.DebugError($"Resource handles were empty... [{LoadRequest.Key}]", LoadRequest);
+                        }
+                        else
+                        {
+                            return await AddressableLoadProcess.LoadAssetAsync<T>(LoadRequest);
+                        }
+                    }
+                    else
+                    {
+                        AddressableDebug.DebugError("Resource handles result was null", LoadRequest);
+                    }
+                }
+                LoadRequest.IsLoading = false;
+            }
+            catch (Exception E)
+            {
+                AddressableDebug.DebugError(E.StackTrace + " " + E.Message, LoadRequest);
+            }
+            LoadRequest.IsLoading = false;
+            return false;
+        }
+        /// <summary>
+        /// Unloads the previously loaded addressable asset.
+        /// </summary>
+        /// <param name="LoadRequest">The load request parameters.</param>
+        /// <returns>True if the resource was unloaded, false otherwise.</returns>
+        public static bool ReleaseResource(AddressableLoadResourceBase loadRequest)
+        {
+            if (loadRequest == null || (loadRequest.Handles?.Count == 0 && loadRequest.ResourceLocationHandles?.Count != 0))
+            {
+                return false;
+            }
+
+            if (loadRequest.Handles != null)
+            {
+                int HandleCount = loadRequest.Handles.Count;
+                for (int HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++)
+                {
+                    UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle handle = loadRequest.Handles[HandleIndex];
+                    Addressables.Release(handle);
+                }
+                loadRequest.Handles.Clear();
+            }
+
+            if (loadRequest.ResourceLocationHandles.Count != 0)
+            {
+                Addressables.Release(loadRequest.ResourceLocationHandles);
+            }
+
+            return true;
+        }
+    }
+}

Basis/Packages/com.basis.addressables/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 BasisVR
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.