public AssetProcessService(ISettingsRepository settingsRepository, IEntryRulesRepository entryRulesRepository,
IAssetDatabaseAdapter assetDatabaseAdapter, IAddressablesEditorAdapter addressablesEditorAdapter)
{
// Create AddressableAssetSettings asset if it does not exists.
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettingsDefaultObject.Settings = AddressableAssetSettings.Create(
AddressableAssetSettingsDefaultObject.kDefaultConfigFolder,
AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
var addressableSettings = AddressableAssetSettingsDefaultObject.Settings;
var addressablePathGenerateService = new AddressablePathGenerateDomainService();
var addressGenerateService = new AddressGenerateDomainService(addressablePathGenerateService);
var groupNameService = new GroupNameGenerateDomainService(assetDatabaseAdapter);
var entryOperationInfoBuildService =
new EntryOperationInfoBuildDomainService(addressablePathGenerateService, addressGenerateService,
groupNameService, assetDatabaseAdapter);
var entryOperationInfoApplyService =
new EntryOperationInfoApplyDomainService(addressablesEditorAdapter, assetDatabaseAdapter);
_domainService = new AssetProcessDomainService(settingsRepository, entryRulesRepository,
addressableSettings, assetDatabaseAdapter, entryOperationInfoBuildService,
entryOperationInfoApplyService, addressablePathGenerateService);
}
public void Setup()
{
DirectoryUtility.DeleteDirectory(TestFolder, false);
Directory.CreateDirectory(ConfigFolder);
m_Settings = AddressableAssetSettings.Create(ConfigFolder, "AddressableAssetSettings.Tests", true, true);
CreateAddressablePrefab("test");
}
static public void Setup(string testType, string pathFormat, string suffix)
{
#if UNITY_EDITOR
var activeScenePath = EditorSceneManager.GetActiveScene().path;
var RootFolder = string.Format(pathFormat, testType, suffix);
Directory.CreateDirectory(RootFolder);
var settings = AddressableAssetSettings.Create(RootFolder + "/Settings", "AddressableAssetSettings.Tests", false, true);
var group = settings.FindGroup("TestStuff" + suffix);
if (group == null)
{
group = settings.CreateGroup("TestStuff" + suffix, true, false, false, null, typeof(BundledAssetGroupSchema));
}
settings.DefaultGroup = group;
AssetDatabase.StartAssetEditing();
for (int i = 0; i < kPrefabCount; i++)
{
var guid = CreateAsset(RootFolder + "/test" + i + suffix + ".prefab", "testPrefab" + i);
var entry = settings.CreateOrMoveEntry(guid, group, false, false);
entry.address = Path.GetFileNameWithoutExtension(entry.AssetPath);
entry.SetLabel(GetPrefabLabel(suffix), true, false);
entry.SetLabel(GetPrefabAlternatingLabel(suffix, i), true, false);
entry.SetLabel(GetPrefabUniqueLabel(suffix, i), true, false);
}
#if ENABLE_SCENE_TESTS
for (int i = 0; i < kSceneCount; i++)
{
var scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
EditorSceneManager.SaveScene(scene, RootFolder + "/test_scene" + i + suffix + ".unity");
var guid = AssetDatabase.AssetPathToGUID(scene.path);
var entry = settings.CreateOrMoveEntry(guid, group, false, false);
entry.address = Path.GetFileNameWithoutExtension(entry.AssetPath);
}
#endif
string assetRefGuid = CreateAsset(RootFolder + "/testIsReference.prefab", "IsReference");
GameObject go = new GameObject("AssetReferenceBehavior");
AssetReferenceTestBehavior aRefTestBehavior = go.AddComponent <AssetReferenceTestBehavior>();
aRefTestBehavior.Reference = settings.CreateAssetReference(assetRefGuid);
aRefTestBehavior.LabelReference = new AssetLabelReference()
{
labelString = settings.labelTable.labelNames[0]
};
string hasBehaviorPath = RootFolder + "/AssetReferenceBehavior.prefab";
PrefabUtility.SaveAsPrefabAsset(go, hasBehaviorPath);
settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(hasBehaviorPath), group, false, false);
AssetDatabase.StopAssetEditing();
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
RunBuilder(settings, testType, suffix);
#if ENABLE_SCENE_TESTS
EditorSceneManager.OpenScene(activeScenePath, OpenSceneMode.Single);
#endif
#endif
}
public void Setup()
{
DirectoryUtility.DeleteDirectory(TempPath, onlyIfEmpty: false, recursiveDelete: true);
Directory.CreateDirectory(TempPath);
m_Settings = AddressableAssetSettings.Create(Path.Combine(TempPath, "Settings"), "AddressableAssetSettings.Tests", true, true);
m_PreviousScenes = EditorBuildSettings.scenes;
}
public void FastModeInit_EventViewerSetup_InitializesDiagnosticEventCollectorCorrectly(bool sendProfilerEvents)
{
//Setup
bool originalValue = ProjectConfigData.PostProfilerEvents;
ProjectConfigData.PostProfilerEvents = sendProfilerEvents;
var settings = AddressableAssetSettings.Create(Path.Combine(GetGeneratedAssetsPath(), "Settings"), "AddressableAssetSettings.Tests", false, true);
//Test
FastModeInitializationOperation fmInit = new FastModeInitializationOperation(m_Addressables, settings);
fmInit.InvokeExecute();
//Assert
if (sendProfilerEvents)
{
Assert.IsNotNull(fmInit.m_Diagnostics, "Diagnostic event collector was null when send profiler events was set to true.");
}
else
{
Assert.IsNull(fmInit.m_Diagnostics, "Diagnostic event collector was not null when send profiler events was false.");
}
//Cleanup
ProjectConfigData.PostProfilerEvents = originalValue;
}
public static void AddressablesReset()
{
ClearMissFile();
string folderPath = Application.dataPath + "/AddressableAssetsData";
AddressableAssetSettingsDefaultObject.Settings = AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder, AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
string[] folders = { "Assets/ResourcesAsset", "Assets/Scenes", "Assets/Lua", "Assets/ToLua/Lua" };
//string[] folders = { "Assets/Lua", "Assets/ToLua/Lua" };
List <string> paths = new List <string>();
foreach (string folder in folders)
{
foreach (string subFile in Directory.GetFiles(folder, "*.*", SearchOption.AllDirectories))
{
if (!subFile.EndsWith(".meta"))
{
var newPath = subFile.Replace("\\", "/");
paths.Add(newPath);
}
}
}
AssetPostprocess.PostprocessAssets(paths.ToArray());
EditorUtility.SetDirty(AddressableAssetSettingsDefaultObject.Settings);
AssetDatabase.Refresh();
AssetDatabase.SaveAssets();
}
private void Refresh()
{
// Create AddressableAssetSettings asset if it does not exists.
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettingsDefaultObject.Settings = AddressableAssetSettings.Create(
AddressableAssetSettingsDefaultObject.kDefaultConfigFolder,
AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
var settingsRepository = new SettingsRepository();
var entryRulesRepository = new EntryRulesRepository();
_addressableSettings = AddressableAssetSettingsDefaultObject.Settings;
var addressablesEditorAdapter = new AddressablesEditorAdapter(_addressableSettings);
var assetDatabaseAdapter = new AssetDatabaseAdapter();
AssetProcessService = new AssetProcessService(settingsRepository, entryRulesRepository,
assetDatabaseAdapter,
addressablesEditorAdapter);
SettingsService = new SettingsService(settingsRepository);
EntryRulesService = new EntryRulesService(entryRulesRepository);
SettingsEditorPresenter = new SettingsEditorPresenter(SettingsService);
SettingsEditorController = new SettingsEditorController(SettingsService, AssetProcessService);
EntryRulesEditorPresenter = new EntryRulesEditorPresenter(EntryRulesService);
EntryRulesEditorController = new EntryRulesEditorController(EntryRulesService, AssetProcessService);
}
void IPrebuildSetup.Setup()
{
#if UNITY_EDITOR
bool currentIgnoreState = LogAssert.ignoreFailingMessages;
LogAssert.ignoreFailingMessages = true;
var activeScenePath = EditorSceneManager.GetActiveScene().path;
string rootFolder = Path.Combine("Assets", "gen", m_UniqueTestName);
if (Directory.Exists(rootFolder))
{
Directory.Delete(rootFolder, true);
}
Directory.CreateDirectory(rootFolder);
AddressableAssetSettings settings = AddressableAssetSettings.Create(Path.Combine(rootFolder, "Settings"), "AddressableAssetSettings.Tests", false, true);
Setup(settings, rootFolder);
RunBuilder(settings);
if (activeScenePath != EditorSceneManager.GetActiveScene().path)
{
EditorSceneManager.OpenScene(activeScenePath, OpenSceneMode.Single);
}
LogAssert.ignoreFailingMessages = currentIgnoreState;
#endif
}
public void CreateCatalogFiles_BundleLocalCatalog_BuildRemoteCatalog_ShouldCreateCatalogBundleAndRemoteJsonCatalog()
{
// Creating a bundle causes a domain reload and settings need to be persisted to be able to access profile variables.
m_PersistedSettings = AddressableAssetSettings.Create(k_TestConfigFolder, k_TestConfigName, true, true);
Setup();
Settings.BundleLocalCatalog = true;
Settings.BuildRemoteCatalog = true;
Settings.RemoteCatalogBuildPath = new ProfileValueReference();
Settings.RemoteCatalogBuildPath.SetVariableByName(Settings, AddressableAssetSettings.kRemoteBuildPath);
Settings.RemoteCatalogLoadPath = new ProfileValueReference();
Settings.RemoteCatalogLoadPath.SetVariableByName(Settings, AddressableAssetSettings.kRemoteLoadPath);
var defaultFileName = m_BuilderInput.RuntimeCatalogFilename;
var bundleFileName = defaultFileName.Replace(".json", ".bundle");
var jsonText = "Some text in catalog file";
var result = m_BuildScript.CreateCatalogFiles(jsonText, m_BuilderInput, m_BuildContext);
Assert.IsTrue(result);
// Assert locations
Assert.AreEqual(3, m_RuntimeData.CatalogLocations.Count);
Assert.AreEqual(1, m_RuntimeData.CatalogLocations.Count(l => l.InternalId.EndsWith(bundleFileName)));
Assert.AreEqual(2, m_RuntimeData.CatalogLocations.Count(l => l.InternalId.EndsWith(".hash")));
// Assert file paths
var remoteBuildFolder = Settings.RemoteCatalogBuildPath.GetValue(Settings);
var registryPaths = m_BuilderInput.Registry.GetFilePaths().ToList();
Assert.AreEqual(3, registryPaths.Count);
Assert.AreEqual(1, registryPaths.Count(p => p.EndsWith(bundleFileName)));
Assert.AreEqual(1, registryPaths.Count(p => p.Contains(remoteBuildFolder) && p.EndsWith(".json")));
Assert.AreEqual(1, registryPaths.Count(p => p.Contains(remoteBuildFolder) && p.EndsWith(".hash")));
var registryBundlePath = registryPaths.First(p => p.EndsWith(bundleFileName));
var registryRemoteCatalogPath = registryPaths.First(p => p.Contains(remoteBuildFolder) && p.EndsWith(".json"));
var registryRemoteHashPath = registryPaths.First(p => p.Contains(remoteBuildFolder) && p.EndsWith(".hash"));
Assert.IsTrue(File.Exists(registryBundlePath));
Assert.IsTrue(File.Exists(registryRemoteCatalogPath));
Assert.IsTrue(File.Exists(registryRemoteHashPath));
// Assert catalogs
m_AssetBundle = AssetBundle.LoadFromFile(registryBundlePath);
Assert.IsNotNull(m_AssetBundle);
var assets = m_AssetBundle.LoadAllAssets <TextAsset>();
Assert.AreEqual(1, assets.Length);
Assert.AreEqual(jsonText, assets.First().text);
var remoteCatalogText = File.ReadAllText(registryRemoteCatalogPath);
Assert.AreEqual(jsonText, remoteCatalogText);
File.Delete(registryRemoteCatalogPath);
File.Delete(registryRemoteHashPath);
}
/// <summary>
/// Gets the settings object with the option to create a new one if it does not exist.
/// </summary>
/// <param name="create">If true and no settings object exists, a new one will be created using the default config folder and asset name.</param>
/// <returns>The default settings object.</returns>
public static AddressableAssetSettings GetSettings(bool create)
{
if (Settings == null && create)
{
Settings = AddressableAssetSettings.Create(kDefaultConfigFolder, kDefaultConfigAssetName, true, true);
}
return(Settings);
}
internal static void AddAssetsToAddressablesGroup(HashSet <string> assetsAdded, string groupName = "")
{
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettingsDefaultObject.Settings =
AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder,
AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
var settings = AddressableAssetSettingsDefaultObject.Settings;
if (settings == null)
{
Debug.LogWarningFormat("[Addressables] settings file not found.\nPlease go to Menu/Window/Asset Management/Addressables/Groups, then click 'Create Addressables Settings' button.");
return;
}
List <AddressableAssetEntry> groupEntriesModified = new List <AddressableAssetEntry>();
var parseGroupNames = string.IsNullOrEmpty(groupName);
foreach (var assetPath in assetsAdded)
{
string guid = AssetDatabase.AssetPathToGUID(assetPath);
string platform;
string language;
AkAssetUtilities.ParseAssetPath(assetPath, out platform, out language);
if (parseGroupNames)
{
if (string.IsNullOrEmpty(platform))
{
Debug.LogError($"Wwise Addressables import : could not parse platform for {assetPath}.");
continue;
}
groupName = $"WwiseData_{platform}";
if (Path.GetFileName(assetPath) == "Init.bnk")
{
groupName = $"WwiseData_{platform}_InitBank";
}
}
AddressableAssetGroup group = GetOrAddGroup(settings, groupName);
var groupEntry = settings.CreateOrMoveEntry(guid, group);
if (groupEntry != null)
{
groupEntriesModified.Add(groupEntry);
}
}
if (groupEntriesModified.Count > 0)
{
settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, groupEntriesModified, true);
AssetDatabase.SaveAssets();
}
}
protected AddressableAssetSettings CreateSettings(string name, string rootFolder)
{
if (Directory.Exists(rootFolder))
{
Directory.Delete(rootFolder, true);
}
Directory.CreateDirectory(rootFolder);
return(AddressableAssetSettings.Create(Path.Combine(rootFolder, name), "AddressableAssetSettings.Tests", false, true));
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
CreateGroup(settings, tempAssetFolder, kOldBuildId, GetNonRefAsset);
RunBuilder(settings, m_UniqueTestName + kOldBuildId);
settings = AddressableAssetSettings.Create(Path.Combine(tempAssetFolder, "Settings" + kNewBuildId), "AddressableAssetSettings.Tests", false, true);
CreateGroup(settings, tempAssetFolder, kNewBuildId, GetRefAsset);
RunBuilder(settings, m_UniqueTestName + kNewBuildId);
}
public void Setup()
{
m_Manager = new HostingServicesManager();
m_Settings = AddressableAssetSettings.Create(k_TestConfigFolder, k_TestConfigName, false, false);
m_Settings.HostingServicesManager = m_Manager;
var group = m_Settings.CreateGroup("testGroup", false, false, false, null);
group.AddSchema <BundledAssetGroupSchema>();
m_Settings.groups.Add(group);
}
static void InitializeAddressablesSettings()
{
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettingsDefaultObject.Settings = AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder,
AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName,
true,
true);
}
}
public void Setup()
{
if (Directory.Exists(TempPath))
{
Directory.Delete(TempPath, true);
File.Delete(TempPath + ".meta");
}
Directory.CreateDirectory(TempPath);
m_Settings = AddressableAssetSettings.Create(Path.Combine(TempPath, "Settings"), "AddressableAssetSettings.Tests", true, true);
}
public void Setup()
{
m_SingleTestBuildFolder = "Temp/TestBuild";
m_SingleTestAssetFolder = "Assets/SingleTestFolder";
DeleteSingleTestDirectories();
Directory.CreateDirectory(m_SingleTestBuildFolder);
Directory.CreateDirectory(m_SingleTestAssetFolder);
AddressableAssetSettings settings = AddressableAssetSettings.Create(Path.Combine(m_SingleTestAssetFolder, "Settings"), "AddressableAssetSettings.Tests", false, true);
m_SettingsPath = settings.AssetPath;
}
public void Setup()
{
if (AssetDatabase.IsValidFolder($"Assets/{TempPath}"))
{
AssetDatabase.DeleteAsset($"Assets/{TempPath}");
AssetDatabase.Refresh();
}
AssetDatabase.CreateFolder("Assets", "TempGen");
m_PreviousScenes = EditorBuildSettings.scenes;
m_Settings = AddressableAssetSettings.Create(GetPath("Settings"), "AddressableAssetSettings.Tests", true, true);
AssetDatabase.Refresh();
}
IHostingService GetManagedService(out AddressableAssetSettings settings)
{
var m = new HostingServicesManager();
settings = AddressableAssetSettings.Create(k_TestConfigFolder, k_TestConfigName, false, false);
settings.HostingServicesManager = m;
var group = settings.CreateGroup("testGroup", false, false, false, null);
group.AddSchema <BundledAssetGroupSchema>();
settings.groups.Add(group);
m.Initialize(settings);
return(m.AddHostingService(m_Service.GetType(), "test"));
}
public void Setup()
{
using (new IgnoreFailingLogMessage())
{
if (AssetDatabase.IsValidFolder(TempPath))
{
AssetDatabase.DeleteAsset(TempPath);
}
Directory.CreateDirectory(TempPath);
m_Settings = AddressableAssetSettings.Create(Path.Combine(TempPath, "Settings"),
"AddressableAssetSettings.Tests", false, true);
}
}
public void FastModeInitialization_SetsExceptionHandlerToNull_WhenLogRuntimeExceptionsIsOff(bool logRuntimeExceptions)
{
//Setup
var settings = AddressableAssetSettings.Create(Path.Combine(GetGeneratedAssetsPath(), "Settings"), "AddressableAssetSettings.Tests", false, true);
settings.buildSettings.LogResourceManagerExceptions = logRuntimeExceptions;
//Test
FastModeInitializationOperation fmInit = new FastModeInitializationOperation(m_Addressables, settings);
fmInit.InvokeExecute();
//Assert
Assert.AreEqual(logRuntimeExceptions, ResourceManager.ExceptionHandler != null);
}
public void CatalogBuiltWithDifferentGroupOrder_AreEqualWhenOrderEnabled()
{
m_PersistedSettings = AddressableAssetSettings.Create(ConfigFolder, k_TestConfigName, true, true);
Setup();
var buildScript = ScriptableObject.CreateInstance <BuildScriptPackedMode>();
AddressableAssetGroup group1 = Settings.CreateGroup("simpleGroup1", false, false, false,
new List <AddressableAssetGroupSchema>(), typeof(BundledAssetGroupSchema));
Settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(Path.Combine(ConfigFolder, "test 1.prefab")),
group1, false, false);
AddressableAssetGroup group2 = Settings.CreateGroup("simpleGroup2", false, false, false,
new List <AddressableAssetGroupSchema>(), typeof(BundledAssetGroupSchema));
Settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(Path.Combine(ConfigFolder, "test 2.prefab")),
group2, false, false);
var r1 = buildScript.BuildData <AddressableAssetBuildResult>(m_BuilderInput);
string p = r1.FileRegistry.GetFilePathForBundle("catalog");
Assert.IsFalse(string.IsNullOrEmpty(p));
string catalogjson1 = File.ReadAllText(p);
Assert.IsFalse(string.IsNullOrEmpty(catalogjson1));
Settings.groups.Remove(group1);
Settings.groups.Remove(group2);
Settings.groups.Add(group2);
Settings.groups.Add(group1);
var r2 = buildScript.BuildData <AddressableAssetBuildResult>(m_BuilderInput);
p = r2.FileRegistry.GetFilePathForBundle("catalog");
Assert.IsFalse(string.IsNullOrEmpty(p));
string catalogjson2 = File.ReadAllText(p);
Assert.IsFalse(string.IsNullOrEmpty(catalogjson2));
int h1 = catalogjson1.GetHashCode();
int h2 = catalogjson2.GetHashCode();
Settings.RemoveGroup(group1);
Settings.RemoveGroup(group2);
Assert.AreEqual(h1, h2);
}
public void Setup()
{
TempPath = kTempPath + (ExecCount++).ToString();
if (File.Exists(BuildLayoutGenerationTask.m_LayoutTextFile))
{
File.Delete(BuildLayoutGenerationTask.m_LayoutTextFile);
}
m_PrevGenerateBuildLayout = ProjectConfigData.GenerateBuildLayout;
BuildScriptPackedMode.s_SkipCompilePlayerScripts = true;
ProjectConfigData.GenerateBuildLayout = true;
if (Directory.Exists(TempPath))
{
Directory.Delete(TempPath, true);
}
Directory.CreateDirectory(TempPath);
m_Settings = AddressableAssetSettings.Create(Path.Combine(TempPath, "Settings"), "AddressableAssetSettings.Tests", false, true);
}
public void FastModeInit_EventViewerSetup_InitializesPostProfilerEventsValue(bool sendProfilerEvents)
{
//Setup
bool originalValue = ProjectConfigData.PostProfilerEvents;
ProjectConfigData.PostProfilerEvents = sendProfilerEvents;
var settings = AddressableAssetSettings.Create(Path.Combine(GetGeneratedAssetsPath(), "Settings"), "AddressableAssetSettings.Tests", false, true);
//Test
FastModeInitializationOperation fmInit = new FastModeInitializationOperation(m_Addressables, settings);
fmInit.InvokeExecute();
//Assert
Assert.AreEqual(sendProfilerEvents, m_Addressables.ResourceManager.postProfilerEvents);
//Cleanup
ProjectConfigData.PostProfilerEvents = originalValue;
}
public static void Setup()
{
// Info ファイルを検索
var infoGuid = AssetDatabase.FindAssets("t:AddressableAssetsInfo", null).FirstOrDefault();
if (infoGuid == null)
{
var settings = AddressableAssetSettingsDefaultObject.Settings;
if (settings == null)
{
AddressableAssetSettingsDefaultObject.Settings = AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder, AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
settings = AddressableAssetSettingsDefaultObject.Settings;
}
// リモートサーバにカタログを置くように設定する
settings.BuildRemoteCatalog = true;
settings.RemoteCatalogBuildPath = settings.RemoteCatalogBuildPath;
settings.RemoteCatalogLoadPath = settings.RemoteCatalogLoadPath;
// Remote Load Path の BASE_URL 設定
settings.profileSettings.SetValue(settings.activeProfileId, "RemoteLoadPath", "BASE_URL/[BuildTarget]");
// リモートグループを生成
var remoteGroup = settings.CreateRemoteGroup();
// 同じ階層にinfo ファイルを生成する
var dir = Path.GetDirectoryName(AssetDatabase.GetAssetPath(AddressableAssetSettingsDefaultObject.Settings));
var info = ScriptableObject.CreateInstance <AddressableAssetsInfo>();
AssetDatabase.CreateAsset(info, Path.Combine(dir, "AddressableAssetsInfo.asset"));
// グループをセットする
info.local = settings.DefaultGroup;
info.remote = remoteGroup;
// infoを選択する
Selection.activeObject = info;
}
}
public void Init()
{
//TODO: Remove when NSImage warning issue on bokken is fixed
Application.logMessageReceived += CheckLogForWarning;
if (Directory.Exists(k_TestConfigFolder))
{
AssetDatabase.DeleteAsset(k_TestConfigFolder);
}
if (!Directory.Exists(k_TestConfigFolder))
{
Directory.CreateDirectory(k_TestConfigFolder);
AssetDatabase.Refresh();
}
m_Settings = AddressableAssetSettings.Create(k_TestConfigFolder, k_TestConfigName, true, PersistSettings);
m_Settings.labelTable.labelNames.Clear();
GameObject testObject = new GameObject("TestObject");
#if UNITY_2018_3_OR_NEWER
PrefabUtility.SaveAsPrefabAsset(testObject, k_TestConfigFolder + "/test.prefab");
#else
PrefabUtility.CreatePrefab(k_TestConfigFolder + "/test.prefab", testObject);
#endif
m_AssetGUID = AssetDatabase.AssetPathToGUID(k_TestConfigFolder + "/test.prefab");
OnInit();
//TODO: Remove when NSImage warning issue on bokken is fixed
//Removing here in the event we didn't recieve any messages during the setup, we can respond appropriately to
//logs in the tests.
Application.logMessageReceived -= CheckLogForWarning;
if (resetFailingMessages)
{
LogAssert.ignoreFailingMessages = false;
}
}
public void OnGUI()
{
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
GUILayout.Space(50);
if (GUILayout.Button("Create Addressables Settings"))
{
m_GroupEditor = null;
AddressableAssetSettingsDefaultObject.Settings = AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder, AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
//if (GUILayout.Button("Import Addressables Settings"))
//{
// m_GroupEditor = null;
// var path = EditorUtility.OpenFilePanel("Addressables Settings Object", AddressableAssetSettingsDefaultObject.kDefaultConfigFolder, "asset");
// if (!string.IsNullOrEmpty(path))
// {
// var i = path.ToLower().IndexOf("/assets/");
// if (i > 0)
// {
// path = path.Substring(i + 1);
// Addressables.LogFormat("Loading Addressables Settings from {0}", path);
// var obj = AssetDatabase.LoadAssetAtPath<AddressableAssetSettings>(path);
// if (obj != null)
// AddressableAssetSettingsDefaultObject.Settings = obj;
// else
// Debug.LogWarning("Unable to load asset settings from: "
// + path
// + "\nPlease ensure the location included in the project directory."
// );
// }
// }
//}
GUILayout.Space(20);
GUILayout.BeginHorizontal();
GUILayout.Space(50);
UnityEngine.GUI.skin.label.wordWrap = true;
GUILayout.Label("Click the \"Create\" button above or simply drag an asset into this window to start using Addressables. Once you begin, the Addressables system will save some assets to your project to keep up with its data");
GUILayout.Space(50);
GUILayout.EndHorizontal();
switch (Event.current.type)
{
case EventType.DragPerform:
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
foreach (var path in DragAndDrop.paths)
{
if (AddressableAssetUtility.IsPathValidForEntry(path))
{
var guid = AssetDatabase.AssetPathToGUID(path);
if (!string.IsNullOrEmpty(guid))
{
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettingsDefaultObject.Settings = AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder, AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
Undo.RecordObject(AddressableAssetSettingsDefaultObject.Settings, "AddressableAssetSettings");
AddressableAssetSettingsDefaultObject.Settings.CreateOrMoveEntry(guid, AddressableAssetSettingsDefaultObject.Settings.DefaultGroup);
}
}
}
break;
case EventType.DragUpdated:
case EventType.DragExited:
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
break;
}
}
else
{
Rect contentRect = new Rect(0, 0, position.width, position.height);
if (m_GroupEditor == null)
{
m_GroupEditor = new AddressableAssetsSettingsGroupEditor(this);
m_GroupEditor.OnEnable();
}
if (m_GroupEditor.OnGUI(contentRect))
{
Repaint();
}
}
}
static public void Setup(string testType, string pathFormat, string suffix)
{
#if UNITY_EDITOR
bool currentIgnoreState = LogAssert.ignoreFailingMessages;
LogAssert.ignoreFailingMessages = true;
var RootFolder = string.Format(pathFormat, testType, suffix);
Directory.CreateDirectory(RootFolder);
var settings = AddressableAssetSettings.Create(RootFolder + "/Settings", "AddressableAssetSettings.Tests", false, true);
settings.MaxConcurrentWebRequests = kMaxWebRequestCount;
var group = settings.FindGroup("TestStuff" + suffix);
if (group == null)
{
group = settings.CreateGroup("TestStuff" + suffix, true, false, false, null, typeof(BundledAssetGroupSchema));
}
group.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
settings.DefaultGroup = group;
for (int i = 0; i < kPrefabCount; i++)
{
var guid = CreateAsset(RootFolder + "/test" + i + suffix + ".prefab", "testPrefab" + i);
var entry = settings.CreateOrMoveEntry(guid, group, false, false);
entry.address = Path.GetFileNameWithoutExtension(entry.AssetPath);
entry.SetLabel(GetPrefabLabel(suffix), true, true);
entry.SetLabel(GetPrefabAlternatingLabel(suffix, i), true, true);
entry.SetLabel(GetPrefabUniqueLabel(suffix, i), true, true);
}
var texture = new Texture2D(32, 32);
var data = ImageConversion.EncodeToPNG(texture);
UnityEngine.Object.DestroyImmediate(texture);
AssetDatabase.GenerateUniqueAssetPath(RootFolder);
var spritePath = RootFolder + "/sprite.png";
File.WriteAllBytes(spritePath, data);
AssetDatabase.ImportAsset(spritePath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var spriteGuid = AssetDatabase.AssetPathToGUID(spritePath);
var importer = (TextureImporter)AssetImporter.GetAtPath(spritePath);
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Multiple;
importer.spritesheet = new SpriteMetaData[] { new SpriteMetaData()
{
name = "topleft", pivot = Vector2.zero, rect = new Rect(0, 0, 16, 16)
},
new SpriteMetaData()
{
name = "botright", pivot = Vector2.zero, rect = new Rect(16, 16, 16, 16)
} };
importer.SaveAndReimport();
var spriteEntry = settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(spritePath), group, false, false);
spriteEntry.address = "sprite";
var so = ScriptableObject.CreateInstance <UnityEngine.AddressableAssets.Tests.TestObject>();
var sub = ScriptableObject.CreateInstance <UnityEngine.AddressableAssets.Tests.TestObject>();
sub.name = "sub-shown";
var sub2 = ScriptableObject.CreateInstance <UnityEngine.AddressableAssets.Tests.TestObject>();
sub2.hideFlags |= HideFlags.HideInHierarchy;
sub2.name = "sub2-hidden";
so.name = "main";
AssetDatabase.CreateAsset(so, RootFolder + "/assetWithSubObjects.asset");
AssetDatabase.AddObjectToAsset(sub, RootFolder + "/assetWithSubObjects.asset");
AssetDatabase.AddObjectToAsset(sub2, RootFolder + "/assetWithSubObjects.asset");
AssetDatabase.ImportAsset(RootFolder + "/assetWithSubObjects.asset", ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
var assetWithSubObjectsGUID = AssetDatabase.AssetPathToGUID(RootFolder + "/assetWithSubObjects.asset");
string assetRefGuid = CreateAsset(RootFolder + "/testIsReference.prefab", "IsReference");
GameObject go = new GameObject("AssetReferenceBehavior");
AssetReferenceTestBehavior aRefTestBehavior = go.AddComponent <AssetReferenceTestBehavior>();
settings.CreateOrMoveEntry(assetWithSubObjectsGUID, settings.DefaultGroup).address = "assetWithSubObjects";
aRefTestBehavior.Reference = settings.CreateAssetReference(assetRefGuid);
aRefTestBehavior.ReferenceWithSubObject = settings.CreateAssetReference(assetWithSubObjectsGUID);
aRefTestBehavior.ReferenceWithSubObject.SubObjectName = "sub-shown";
aRefTestBehavior.LabelReference = new AssetLabelReference()
{
labelString = settings.labelTable.labelNames[0]
};
string hasBehaviorPath = RootFolder + "/AssetReferenceBehavior.prefab";
PrefabUtility.SaveAsPrefabAsset(go, hasBehaviorPath);
settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(hasBehaviorPath), group, false, false);
//AssetDatabase.StopAssetEditing();
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
RunBuilder(settings, testType, suffix);
LogAssert.ignoreFailingMessages = currentIgnoreState;
#endif
}
internal static void AddAssetsToAddressablesGroup(HashSet <string> assetsAdded, string groupName = "")
{
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettingsDefaultObject.Settings =
AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder,
AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
var settings = AddressableAssetSettingsDefaultObject.Settings;
if (settings == null)
{
Debug.LogWarningFormat("[Addressables] settings file not found.\nPlease go to Menu/Window/Asset Management/Addressables/Groups, then click 'Create Addressables Settings' button.");
return;
}
List <AddressableAssetEntry> groupEntriesModified = new List <AddressableAssetEntry>();
var parseGroupNames = string.IsNullOrEmpty(groupName);
foreach (var assetPath in assetsAdded)
{
string guid = AssetDatabase.AssetPathToGUID(assetPath);
string platform;
string language;
AkAddressablesEditorUtilities.ParseAssetPath(assetPath, out platform, out language);
AddressableMetadata assetMetadata = ScriptableObject.CreateInstance <AddressableMetadata>();
if (parseGroupNames)
{
if (string.IsNullOrEmpty(platform))
{
Debug.LogError($"Wwise Addressables import : could not parse platform for {assetPath}. It will not be made addressable.");
continue;
}
if (GetAssetMetadataDelegate != null)
{
if (!GetAssetMetadataDelegate.Invoke(Path.GetFileName(assetPath), platform, language, ref assetMetadata))
{
// If we can't find a metadata asset use the default group name
assetMetadata.groupName = GetDefaultAddressableGroup(Path.GetFileName(assetPath), platform);
}
}
else
{
assetMetadata.groupName = GetDefaultAddressableGroup(Path.GetFileName(assetPath), platform);
}
}
else
{
assetMetadata.groupName = groupName;
}
AddressableAssetGroup group = GetOrAddGroup(settings, assetMetadata.groupName);
var groupEntry = settings.CreateOrMoveEntry(guid, group);
if (groupEntry != null)
{
if (assetMetadata.labels.Count > 0)
{
foreach (string label in assetMetadata.labels)
{
groupEntry.labels.Add(label);
}
}
groupEntriesModified.Add(groupEntry);
}
}
if (groupEntriesModified.Count > 0)
{
settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, groupEntriesModified, true);
AssetDatabase.SaveAssets();
}
}
public void Build(SpaceNode rootNode, DisposableList <HLODBuildInfo> infos, GameObject root,
float cullDistance, float lodDistance, bool writeNoPrefab, bool extractMaterial, Action <float> onProgress)
{
dynamic options = m_streamingOptions;
string path = options.OutputDirectory;
HLODTreeNodeContainer container = new HLODTreeNodeContainer();
HLODTreeNode convertedRootNode = ConvertNode(container, rootNode);
//create settings if there is no settings.
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder, AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
var settings = AddressableAssetSettingsDefaultObject.GetSettings(true);
var group = GetGroup(settings, options.AddressablesGroupName);
m_shaderGuids.Clear();
if (onProgress != null)
{
onProgress(0.0f);
}
HLODData.TextureCompressionData compressionData;
compressionData.PCTextureFormat = options.PCCompression;
compressionData.WebGLTextureFormat = options.WebGLCompression;
compressionData.AndroidTextureFormat = options.AndroidCompression;
compressionData.iOSTextureFormat = options.iOSCompression;
compressionData.tvOSTextureFormat = options.tvOSCompression;
string filenamePrefix = $"{path}{root.name}";
if (Directory.Exists(path) == false)
{
Directory.CreateDirectory(path);
}
Dictionary <int, HLODData> hlodDatas = new Dictionary <int, HLODData>();
for (int i = 0; i < infos.Count; ++i)
{
if (hlodDatas.ContainsKey(infos[i].ParentIndex) == false)
{
HLODData newData = new HLODData();
newData.CompressionData = compressionData;
hlodDatas.Add(infos[i].ParentIndex, newData);
}
HLODData data = hlodDatas[infos[i].ParentIndex];
data.AddFromWokringObjects(infos[i].Name, infos[i].WorkingObjects);
data.AddFromWorkingColliders(infos[i].Name, infos[i].Colliders);
if (writeNoPrefab)
{
if (hlodDatas.ContainsKey(i) == false)
{
HLODData newData = new HLODData();
newData.CompressionData = compressionData;
hlodDatas.Add(i, newData);
}
HLODData prefabData = hlodDatas[i];
var spaceNode = infos[i].Target;
for (int oi = 0; oi < spaceNode.Objects.Count; ++oi)
{
if (PrefabUtility.IsAnyPrefabInstanceRoot(spaceNode.Objects[oi]) == false)
{
prefabData.AddFromGameObject(spaceNode.Objects[oi]);
}
}
}
if (onProgress != null)
{
onProgress((float)i / (float)infos.Count);
}
}
if (extractMaterial)
{
ExtractMaterial(hlodDatas, filenamePrefix);
}
Dictionary <int, RootData> rootDatas = new Dictionary <int, RootData>();
foreach (var item in hlodDatas)
{
string filename = $"{filenamePrefix}_group{item.Key}.hlod";
using (Stream stream = new FileStream(filename, FileMode.Create))
{
HLODDataSerializer.Write(stream, item.Value);
stream.Close();
}
AssetDatabase.ImportAsset(filename, ImportAssetOptions.ForceUpdate);
RootData rootData = AssetDatabase.LoadAssetAtPath <RootData>(filename);
m_manager.AddGeneratedResource(rootData);
AddAddress(settings, group, rootData);
rootDatas.Add(item.Key, rootData);
}
var addressableController = root.AddComponent <AddressableHLODController>();
for (int i = 0; i < infos.Count; ++i)
{
var spaceNode = infos[i].Target;
var hlodTreeNode = convertedTable[infos[i].Target];
for (int oi = 0; oi < spaceNode.Objects.Count; ++oi)
{
int highId = -1;
GameObject obj = spaceNode.Objects[oi];
if (PrefabUtility.IsPartOfAnyPrefab(obj) == false)
{
GameObject rootGameObject = null;
if (rootDatas.ContainsKey(i))
{
rootGameObject = rootDatas[i].GetRootObject(obj.name);
}
if (rootGameObject != null)
{
GameObject go = PrefabUtility.InstantiatePrefab(rootGameObject) as GameObject;
go.transform.SetParent(obj.transform.parent);
go.transform.localPosition = obj.transform.localPosition;
go.transform.localRotation = obj.transform.localRotation;
go.transform.localScale = obj.transform.localScale;
if (m_manager.IsGeneratedResource(obj))
{
m_manager.AddGeneratedResource(go);
}
else
{
m_manager.AddConvertedPrefabResource(go);
}
spaceNode.Objects.Add(go);
Object.DestroyImmediate(obj);
continue;
}
}
var address = GetAddress(spaceNode.Objects[oi]);
if (string.IsNullOrEmpty(address) && PrefabUtility.IsAnyPrefabInstanceRoot(spaceNode.Objects[oi]))
{
AddAddress(settings, group, spaceNode.Objects[oi]);
address = GetAddress(spaceNode.Objects[oi]);
}
if (address != null)
{
highId = addressableController.AddHighObject(address, spaceNode.Objects[oi]);
}
else
{
highId = addressableController.AddHighObject(spaceNode.Objects[oi]);
}
hlodTreeNode.HighObjectIds.Add(highId);
}
{
if (rootDatas[infos[i].ParentIndex].GetRootObject(infos[i].Name) != null)
{
string filename = $"{filenamePrefix}_group{infos[i].ParentIndex}.hlod";
int lowId = addressableController.AddLowObject(filename + "[" + infos[i].Name + "]");
hlodTreeNode.LowObjectIds.Add(lowId);
}
}
}
var shaderEntriesAdded = new List <AddressableAssetEntry>();
foreach (var shaderGuid in m_shaderGuids)
{
if (IsExistsInAddressables(shaderGuid) == false)
{
shaderEntriesAdded.Add(settings.CreateOrMoveEntry(shaderGuid, group, false, false));
}
}
settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, shaderEntriesAdded, true);
m_shaderGuids.Clear();
addressableController.Container = container;
addressableController.Root = convertedRootNode;
addressableController.CullDistance = cullDistance;
addressableController.LODDistance = lodDistance;
}
