update url and package name

update documentation url

update subdomain

update subdomain

Author: joaoborks

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 MyGameDevTools
+
+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.

README.md

@@ -1,6 +1,6 @@
-# Advanced Scene Manager Documentation
+# My Scene Manager Documentation
 
-This repository contains the documentation for **Advanced Scene Manager**, a Unity package designed to streamline scene transitions, async operations, and addressable scene management.
+This repository contains the documentation for **My Scene Manager**, a Unity package designed to streamline scene transitions, async operations, and addressable scene management.
 This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
 
 ## Prerequisites

docs/advanced-usage/core-concepts.md

@@ -1,20 +1,20 @@
 ---
 sidebar_position: 1
-description: An introduction to the advanced usage of the Advanced Scene Manager.
+description: An introduction to the advanced usage of My Scene Manager.
 ---
 
 # Core Concepts
 
-There are some key structures that need to be understood in order to dive deep into the logic of the Advanced Scene Manager.
+There are some key structures that need to be understood in order to dive deep into the logic of the My Scene Manager.
 
 ## Architecture
 
-This is an overview of the Advanced Scene Manager architecture. We will dive into each individual component in the next pages.
+This is an overview of the My Scene Manager architecture. We will dive into each individual component in the next pages.
 Consider this flowchart:
 
 ```mermaid
 flowchart TB
-  asm(Advanced Scene Manager)
+  asm(My Scene Manager)
   sd(Core Scene Manager)
   isd([ISceneManager])
   so{{Load, Unload or Transition}}
@@ -42,7 +42,7 @@ flowchart TB
   sr === so
 ```
 
-- The `AdvancedSceneManager` is a static implementation of a `CoreSceneManager`, which contains all the logic to perform **Scene Operations**.
+- The `MySceneManager` is a static implementation of a `CoreSceneManager`, which contains all the logic to perform **Scene Operations**.
 - The `CoreSceneManager` is an implementation of the `ISceneManager` interface, that by itself only defines "low-level" **Scene Operations** methods that receive `SceneParameter` arguments.
 - The `SceneParameter` struct is an abstraction to handle a single `ILoadSceneInfo` or multiple (`ILoadSceneInfo[]`).
 - The `ILoadSceneInfo` interface is an abstraction of a reference to a scene. It has the following implementations:

docs/advanced-usage/core-scene-manager.md

@@ -89,7 +89,7 @@ new CoreSceneManager(initializationScenes: new Scene[]);
 ```
 
 :::note
-You don't need to manually create a `CoreSceneManager` instance if you're using the `AdvancedSceneManager`.
+You don't need to manually create a `CoreSceneManager` instance if you're using the `MySceneManager`.
 :::
 
 ## Scene Parameter

docs/advanced-usage/advanced-scene-manager.md renamed to docs/advanced-usage/my-scene-manager.md

@@ -2,11 +2,11 @@
 sidebar_position: 2
 ---
 
-# Advanced Scene Manager
+# My Scene Manager
 
-The `AdvancedSceneManager` is a static wrapper to the `CoreSceneManager` class, that exists to simplify the usage experience of the **Scene Operations**.
+`MySceneManager` is a static wrapper to the `CoreSceneManager` class, that exists to simplify the usage experience of the **Scene Operations**.
 It manages an internal reference to a Core Scene Manager that is created during the `RuntimeInitializeOnLoadMethod` callback, which is executed after the first scene has loaded and after the first `Awake()` cycle.
-That means that the `AdvancedSceneManager` will not be initialized until the first `Start()` cycle.
+That means that `MySceneManager` will not be initialized until the first `Start()` cycle.
 
 ```cs
 [RuntimeInitializeOnLoadMethod]
@@ -18,7 +18,7 @@ internal static void Initialize()
 
 ## Static API
 
-You can optionally disable the `AdvancedSceneManager` static class entirely if you wish to manually handle the `CoreSceneManager` lifecycle and/or extend any functionality.
+You can optionally disable the `MySceneManager` static class entirely if you wish to manually handle the `CoreSceneManager` lifecycle and/or extend any functionality.
 To do it, simply define the scripting symbol `DISABLE_STATIC_SCENE_MANAGER` on your scripting compilation settings.
 
 ## Extension Methods

docs/advanced-usage/scene-transitions.md

@@ -40,4 +40,4 @@ The `WaitForScriptedStart` and `WaitForScriptedEnd` fields in the `LoadingBehavi
 Effectively, this **delays** the start or the end of the **Scene Transition** operation to display a visual feedback such as a fade in/out.
 
 When the `TransitionAsync` method is _awaited_, it will wait until the entire transition has been completed **and** the loading scene has been unloaded.
-If you wish to execute an action exactly when the target scene is loaded, you can either rely on that scene's `Awake()` calls or subscribe to the `SceneLoaded` event from the `CoreSceneManager` or `AdvancedSceneManager`.
+If you wish to execute an action exactly when the target scene is loaded, you can either rely on that scene's `Awake()` calls or subscribe to the `SceneLoaded` event from the `CoreSceneManager` or `MySceneManager`.

docs/getting-started/basic-usage.md

@@ -1,46 +1,46 @@
 ---
 sidebar_position: 3
-description: Basic introduction to the usage of the Advanced Scene Manager.
+description: Basic introduction to the usage of My Scene Manager.
 ---
 
 # Basic Usage
 
 Loading scenes with this package implies that the scenes **will always be loaded as Additive**. That is simply because there is no advantage in loading scenes in the **Single** load scene mode when you expect to work with multiple scenes. 
 
-You will be using the `AdvancedSceneManager` static class to perform the scene operations.
+You will be using the `MySceneManager` static class to perform the scene operations.
 
 ## Loading scenes
 
 You can load scenes by using any of these references:
 
 ```cs
 // Name
-AdvancedSceneManager.LoadAsync("my-scene");
+MySceneManager.LoadAsync("my-scene");
 // Path (relative to the Assets folder)
-AdvancedSceneManager.LoadAsync("Scenes/my-scene");
+MySceneManager.LoadAsync("Scenes/my-scene");
 // Build Index
-AdvancedSceneManager.LoadAsync(1);
+MySceneManager.LoadAsync(1);
 // Address
-AdvancedSceneManager.LoadAddressableAsync("my-scene-address");
+MySceneManager.LoadAddressableAsync("my-scene-address");
 // Asset Reference
-AdvancedSceneManager.LoadAddressableAsync(mySceneAssetReference);
+MySceneManager.LoadAddressableAsync(mySceneAssetReference);
 ```
 
 Additionally, you can also pass an array of scenes (given the same type of reference):
 
 ```cs
 // Array of build indexes
-AdvancedSceneManager.LoadAsync(new int[] { 1, 2, 3});
+MySceneManager.LoadAsync(new int[] { 1, 2, 3});
 ```
 
 The loaded scene can be marked to be set as the active scene:
 
 ```cs
 // Loads a scene and sets it as the active scene
-AdvancedSceneManager.LoadAsync("my-scene", true);
+MySceneManager.LoadAsync("my-scene", true);
 
 // Loads a list of scenes and set the scene at index 1 as the active scene
-AdvancedSceneManager.LoadAsync(new int[] { 1, 2, 3 }, 1);
+MySceneManager.LoadAsync(new int[] { 1, 2, 3 }, 1);
 ```
 
 You can get the progress of the loading operation by passing an `IProgress<float>` implementation, for example:
@@ -55,7 +55,7 @@ public class SimpleProgress : IProgress<float>
 // [...]
 
 SimpleProgress progress = new SimpleProgress();
-AdvancedSceneManager.LoadAsync("my-scene", true, progress);
+MySceneManager.LoadAsync("my-scene", true, progress);
 ```
 
 ## Unloading scenes
@@ -64,24 +64,24 @@ You can unload scenes by using any reference, including the scene itself.
 
 ```cs
 // Name
-AdvancedSceneManager.UnloadAsync("my-scene");
+MySceneManager.UnloadAsync("my-scene");
 // Path (relative to the Assets folder)
-AdvancedSceneManager.UnloadAsync("Scenes/my-scene");
+MySceneManager.UnloadAsync("Scenes/my-scene");
 // Build Index
-AdvancedSceneManager.UnloadAsync(1);
+MySceneManager.UnloadAsync(1);
 // Address
-AdvancedSceneManager.UnloadAddressableAsync("my-scene-address");
+MySceneManager.UnloadAddressableAsync("my-scene-address");
 // Asset Reference
-AdvancedSceneManager.UnloadAddressableAsync(mySceneAssetReference);
+MySceneManager.UnloadAddressableAsync(mySceneAssetReference);
 // Scene
-AdvancedSceneManager.UnloadAsync(AdvancedSceneManager.GetActiveScene());
+MySceneManager.UnloadAsync(MySceneManager.GetActiveScene());
 ```
 
 You can also unload multiple scenes:
 
 ```cs
 // Array of build indexes
-AdvancedSceneManager.UnloadAsync(new int[] { 1, 2, 3});
+MySceneManager.UnloadAsync(new int[] { 1, 2, 3});
 ```
 
 ## Scene Transitions
@@ -91,10 +91,10 @@ You can use the same references from the `LoadAsync` method.
 
 ```cs
 // Name
-AdvancedSceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
+MySceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
 
 // Array of AssetReference
-AdvancedSceneManager.TransitionAddressableAsync(new AssetReference[] { scene1, scene2, scene3 });
+MySceneManager.TransitionAddressableAsync(new AssetReference[] { scene1, scene2, scene3 });
 ```
 
 :::info
@@ -108,13 +108,13 @@ Check the [Loading Scene Examples](../samples/loading-scene-examples.md) Sample
 All scene operations are awaitable and can be used in coroutines as well. For example:
 
 ```cs
-await AdvancedSceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
+await MySceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
 // Do something after the transition
 ```
 
 For coroutines, you must convert the `Task` into a `WaitTask`, which is a helper struct to support coroutines:
 
 ```cs
-yield return AdvancedSceneManager.TransitionAsync("my-target-scene", "my-loading-scene").ToWaitTask();
+yield return MySceneManager.TransitionAsync("my-target-scene", "my-loading-scene").ToWaitTask();
 // Do something after the transition
 ```

docs/getting-started/compatibility.md

@@ -1,6 +1,6 @@
 ---
 sidebar_position: 2
-description: Packages compatible with the Advanced Scene Manager.
+description: Packages compatible with My Scene Manager.
 ---
 
 # Compatibility

docs/getting-started/installation.mdx

@@ -1,6 +1,6 @@
 ---
 sidebar_position: 1
-description: How to install the Advanced Scene Manager package.
+description: How to install the My Scene Manager package.
 ---
 
 import Tabs from '@theme/Tabs';
@@ -48,7 +48,7 @@ This will automatically update your **Scoped Registries** and install the packag
 * Click `Apply`.
 * Open `Window/Package Manager`.
 * In the left column, select `Open UPM` inside `My Registries`.
-* Select `Advanced Scene Manager` under `My GameDev Tools`.
+* Select `My Scene Manager` under `My GameDev Tools`.
 * Click `Install`.
 </TabItem>
 </Tabs>

docs/intro.md

@@ -4,7 +4,7 @@ sidebar_position: 1
 
 # Introduction
 
-The **Advanced Scene Manager** is a powerful Unity package designed to simplify scene management, improve performance, and enhance flexibility in your projects. Whether you're dealing with scene transitions, [Unity Addressables](https://docs.unity3d.com/Manual/com.unity.addressables.html) scenes, or async/await workflows, this package provides an easy-to-use solution for handling all your scene management needs.
+**My Scene Manager** is a powerful Unity package designed to simplify scene management, improve performance, and enhance flexibility in your projects. Whether you're dealing with scene transitions, [Unity Addressables](https://docs.unity3d.com/Manual/com.unity.addressables.html) scenes, or async/await workflows, this package provides an easy-to-use solution for handling all your scene management needs.
 
 ## Key Features
 
@@ -16,7 +16,7 @@ The **Advanced Scene Manager** is a powerful Unity package designed to simplify
 
 ## Instalation
 
-To get started with the Advanced Scene Manager, you can install it in various ways:
+To get started with My Scene Manager, you can install it in various ways:
 
 * [OpenUPM](./getting-started/installation.mdx#openupm)
 * [Install from Git](./getting-started/installation.mdx#git)
@@ -31,5 +31,5 @@ using MyGameDevTools.SceneLoading;
 // [...]
 
 // Transition to a scene with a loading scene
-AdvancedSceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
+MySceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
 ```

docs/samples/loading-scene-examples.md

@@ -12,11 +12,11 @@ This sample showcases different loading scenes and how to use **Scene Transition
 Import the sample through the **Package Manager**.
 
 1. Open `Window/Package Manager`.
-2. Select `Advanced Scene Manager` from the `In Project` list.
+2. Select `My Scene Manager` from the `In Project` list.
 3. In the right panel, select the **Samples** tab.
 4. Click on the `Import` button on the `Loading Scene Examples` item.
 
-The sample assets will be installed to `Samples/Advanced Scene Manager/<version>/Loading Scene Examples`.
+The sample assets will be installed to `Samples/My Scene Manager/<version>/Loading Scene Examples`.
 
 ## Scriptable Render Pipeline Compatibility
 
@@ -29,7 +29,7 @@ After importing the sample, a dialog will appear asking to automatically add the
 This is required to be able to perform **Scene Transitions** with the sample scenes.
 If you ignore this prompt, you'll need to manually add the scenes to the **Build Settings** if you want to play the sample.
 
-You can easily remove the scenes added to the **Build Settings** via the menu item at `Tools/Advanced Scene Manager/Remove 'Loading Scene Examples' from Build Settings`.
+You can easily remove the scenes added to the **Build Settings** via the menu item at `Tools/My Scene Manager/Remove 'Loading Scene Examples' from Build Settings`.
 
 ## Playing the Sample
 
@@ -69,12 +69,12 @@ public class SceneTransitionTrigger : MonoBehaviour
 
     public void TransitionWithLoading(string loadingScene)
     {
-        AdvancedSceneManager.TransitionAsync(_targetScene, loadingScene);
+        MySceneManager.TransitionAsync(_targetScene, loadingScene);
     }
 
     public void Transition()
     {
-        AdvancedSceneManager.TransitionAsync(_targetScene);
+        MySceneManager.TransitionAsync(_targetScene);
     }
 }
 ```

docs/upgrades/from-3-to-4.md

@@ -7,12 +7,13 @@ description: Upgrade from version 3.x to 4.x
 # Upgrading from 3.x to 4.x
 
 The `4.x` update consolidates the changes in the `3.x` and simplifies a few more steps of the usage experience.
-It completely removes the `ISceneLoader` implementations and adds a static `AdvancedSceneManager` class so you don't have to manually control its lifecycle.
+It completely removes the `ISceneLoader` implementations and adds a static `MySceneManager` class so you don't have to manually control its lifecycle.
 
 ## Key Changes
 
-* Changed the `AdvancedSceneManager` to be a static class that auto manages its lifecycle. ([#49](https://github.com/mygamedevtools/scene-loader/issues/49))
-* Converted the former `AdvancedSceneManager` to a new class `CoreSceneManager`, used internally by the new static `AdvancedSceneManager`. ([#49](https://github.com/mygamedevtools/scene-loader/issues/49))
+* Renamed the package to `MySceneManager` from `AdvancedSceneManager` due to collisions with an existing Unity Asset Store product called Advanced Scene Manager.
+* Added the static class `MySceneManager` that auto manages a scene manager lifecycle. ([#49](https://github.com/mygamedevtools/scene-loader/issues/49))
+* Converted the former `AdvancedSceneManager` to a new class `CoreSceneManager`, used internally by the new static `MySceneManager`. ([#49](https://github.com/mygamedevtools/scene-loader/issues/49))
 * Added extension methods to avoid having to create `ILoadSceneInfo` instances manually. ([#49](https://github.com/mygamedevtools/scene-loader/issues/49))
 * Removed the `ISceneLoader` interface and all its implementations: `SceneLoaderAsync`, `SceneLoaderCoroutine` and `SceneLoaderUniTask`. ([#39](https://github.com/mygamedevtools/scene-loader/issues/39))
 * Moved the `Transition` logic to the `ISceneManager` interface directly.
@@ -24,7 +25,7 @@ It completely removes the `ISceneLoader` implementations and adds a static `Adva
 
 ## Code Updates
 
-With the static `AdvancedSceneManager` available, you no longer need to manage an `ISceneManager` lifecycle.
+With the static `MySceneManager` available, you no longer need to manage an `ISceneManager` lifecycle.
 Also, there's no longer need to manually create `ILoadSceneInfo` instances due to the addition of extension methods.
 Consider this `3.x` code:
 
@@ -38,7 +39,7 @@ loader.TransitionToSceneAsync(new LoadSceneInfo("my-target-scene"), new LoadScen
 It can be converted to this `4.x` code:
 
 ```cs
-AdvancedSceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
+MySceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
 ```
 
 ## No more `ISceneLoader`
@@ -111,9 +112,9 @@ You can retrieve the scenes by calling `SceneResult.GetScenes()`.
 ## Advanced Scene Manager Changes
 
 The former `AdvancedSceneManager` was an implementation of the `ISceneManager` class.
-This implementation has been renamed to `CoreSceneManager` and the `AdvancedSceneManager` name has been converted to a static class that internally manages an instance of a `CoreSceneManager`.
+This implementation has been renamed to `CoreSceneManager` and the `MySceneManager` is a new static class that internally manages an instance of a `CoreSceneManager`.
 
-Operationally, the static `AdvancedSceneManager` is a static wrapper to a `CoreSceneManager` instance.
+Operationally, the static `MySceneManager` is a static wrapper to a `CoreSceneManager` instance.
 
 The **Scene Transition** implementation from the former `SceneLoaderAsync` has been migrated to the `CoreSceneManager` class, along with a few improvements.
 
@@ -122,10 +123,10 @@ The **Scene Transition** implementation from the former `SceneLoaderAsync` has b
 With extension methods, you no longer need to manually create `ILoadSceneInfo` instances:
 
 ```cs
-AdvancedSceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
+MySceneManager.TransitionAsync("my-target-scene", "my-loading-scene");
 ```
 
-This works for both the static `AdvancedSceneManager` and any `ISceneManager` implementation.
+This works for both the static `MySceneManager` and any `ISceneManager` implementation.
 The extension methods use the arguments to build a `SceneParameter` internally, such as:
 
 ```cs
@@ -149,13 +150,13 @@ With the removal of the `SceneLoaderCoroutine` and the conversion of the return
 You just have to convert the task to a `WaitTask`, that can be yielded:
 
 ```cs
-yield return AdvancedSceneManager.TransitionAsync("my-target-scene", "my-loading-scene").ToWaitTask();
+yield return MySceneManager.TransitionAsync("my-target-scene", "my-loading-scene").ToWaitTask();
 ```
 
 You can also use the `WaitTask` to get the loaded scene:
 
 ```cs
-WaitTask<SceneResult> waitTask = AdvancedSceneManager.LoadAsync("my-target-scene");
+WaitTask<SceneResult> waitTask = MySceneManager.LoadAsync("my-target-scene");
 yield return waitTask;
 
 Scene loadedScene = waitTask.Task.Result.GetScene();