public void GetSingle_France_GetsCompanyATax()
{
//Arange
var ioc = new IOC();
ioc.Register<ICalculateTax>("CompanyATax", "UK");
ioc.Register<ICalculateTax>("CompanyATax", "France");
ioc.Register<ICalculateTax>("CompanyATax", "USA");
//Act
var item = ioc.GetSingleByCountry<ICalculateTax>("France");
//Asert
Assert.IsInstanceOfType(item, typeof(CompanyATax));
}
private static void CreateAssetLibraryForScene(Scene scene, int index, AssetLibraryAsset asset, AssetFolderInfo folder, HashSet <UnityObject> hs)
{
TypeMap typeMap = new TypeMap();
AssetDB assetDB = new AssetDB();
RuntimeShaderUtil shaderUtil = new RuntimeShaderUtil();
IOC.Register <ITypeMap>(typeMap);
IOC.Register <IAssetDB>(assetDB);
IOC.Register <IRuntimeShaderUtil>(shaderUtil);
PersistentRuntimeScene rtScene = new PersistentRuntimeScene();
GetDepsFromContext ctx = new GetDepsFromContext();
rtScene.GetDepsFrom(scene, ctx);
Queue <UnityObject> depsQueue = new Queue <UnityObject>(ctx.Dependencies.OfType <UnityObject>());
GetDepsFromContext getDepsCtx = new GetDepsFromContext();
while (depsQueue.Count > 0)
{
UnityObject uo = depsQueue.Dequeue();
if (!uo)
{
continue;
}
Type persistentType = typeMap.ToPersistentType(uo.GetType());
if (persistentType != null)
{
getDepsCtx.Clear();
try
{
PersistentObject persistentObject = (PersistentObject)Activator.CreateInstance(persistentType);
//persistentObject.ReadFrom(uo);
persistentObject.GetDepsFrom(uo, getDepsCtx);
}
catch (Exception e)
{
Debug.LogError(e);
}
foreach (UnityObject dep in getDepsCtx.Dependencies)
{
if (!ctx.Dependencies.Contains(dep))
{
ctx.Dependencies.Add(dep);
depsQueue.Enqueue(dep);
}
}
}
}
IOC.Unregister <IRuntimeShaderUtil>(shaderUtil);
IOC.Unregister <ITypeMap>(typeMap);
IOC.Unregister <IAssetDB>(assetDB);
CreateAssetLibrary(ctx.Dependencies.ToArray(), "Scenes/" + scene.name, "SceneAssetLibrary", index, asset, folder, hs);
}
public void Resolve_ReturnsCorrectInstance()
{
IOC.Register <IFoo>(() => { return(new FooImpl()); });
var theFoo = IOC.Resolve <IFoo>();
Assert.IsTrue(theFoo is FooImpl);
}
public static void Main(string[] args)
{
Core.CoreName = "PointCloud Core";
//1.初始化核心
Core core = Core.Instance;
//2.使用注册
core.Use((IOC) =>
{
IOC.Register <IRepository <EntityDemoIdentity, EntityDemo>, RepositoryDemo>(new object[] { 99999 }, Life.Singleton);
IOC.Register <IEventStore, EventStoreDemo>(null, Life.Singleton, "Default", "EventStoreTest");
IOC.Register <ApplicationService, ApplicationServiceDemo>();
IOC.Register <IRPCInvoke, RPCInvoke>(new object[] { "127.0.0.1", 9001 }, Life.Scope, "RPC");
IOC.Register <IRPCProxy, RPCProxy>(new object[] { "127.0.0.1", 9001 }, Life.Scope, "RPC");
});
//3.使用AMQP
core.UseAMQP(() =>
{
RabbitModule module = new RabbitModule("MSI-SU", "suhuyuan", "localhost");
module.Bind(".NETTest", ".NETTest", "1");
return(module);
});
CreateHostBuilder(args).Build().Run();
}
public void GetSingle_UK_GetsCompanyBUKTax_Value()
{
//Arange
var ioc = new IOC();
ioc.Register<ICalculateTax>("CompanyBUKTax", "UK");
ioc.Register<ICalculateTax>("FranceTax", "France");
ioc.Register<ICalculateTax>("USATax", "USA");
//Act
var item = ioc.GetSingleByCountry<ICalculateTax>("UK");
item.Pay = 100;
var value = item.CalculateTax();
//Asert
Assert.AreEqual(value, 90);
}
protected override void Awake()
{
base.Awake();
IOC.Register <IRTEState>(this);
m_resourcePreview = gameObject.AddComponent <ResourcePreviewUtility>();
IOC.Register <IResourcePreviewUtility>(m_resourcePreview);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <GrandeHotelCustomContext>(options => options.UseSqlServer(Configuration.GetConnectionString("grande_hotel")));
services.AddControllers();
services.AddSpaStaticFiles(configuration => configuration.RootPath = "ClientApp/dist");
RegisterJwt(services);
IOC.Register(services, Configuration, _webHostEnvironment.IsDevelopment());
}
public void ResolveImports_ResolvesPrivateMembers()
{
IOC.Register <IFoo>(() => { return(new FooImpl()); });
IOC.Register <IPrivateMemberImport>(() => { return(new PrivateMemberImportImpl()); });
var instance = IOC.Resolve <IPrivateMemberImport>();
Assert.IsNotNull(instance.GetMyFoo());
}
public void Setup()
{
IOC.Reset();
lua = new Lua();
apiBridge = Mock.Interface <IApiBridge>();
IOC.Register <IApiBridge>(() => apiBridge);
IOC.Register <Lua>(() => lua);
IOC.Register <ApiAdapter>(() => new ApiAdapter());
}
private void Awake()
{
m_editor = IOC.Resolve <IRTE>();
IOC.Register <ICustomOutlineRenderersCache>("CustomOutlineRenderersCache", this);
TryToAddRenderers(m_editor.Selection);
m_editor.Selection.SelectionChanged += OnRuntimeEditorSelectionChanged;
m_editor.Object.Enabled += OnObjectEnabled;
m_editor.Object.Disabled += OnObjectDisabled;
}
public void ResolveImportsForObject_ResolvesMembers()
{
IOC.Register <IFoo>(() => { return(new FooImpl()); });
var tmp = new PrivateMemberImportImpl();
IOC.ResolveImports(tmp);
Assert.IsNotNull(tmp.GetMyFoo());
}
protected virtual void AwakeOverride()
{
m_rte = RTE;
IOC.Register <IRTE>(m_rte);
IOC.Register(m_rte);
m_resourcePreview = ResourcePreview;
m_rteAppearance = RTEAppearance;
}
public void Init()
{
IOC.Reset();
IOC.Register <ITestEnvironment>(() => {
ted = new TestEnvDummy();
return(ted);
});
IOC.Register <ITestContext>(() => new MutagenRuntime.TestContext());
Api.Init();
}
public void ResolveImports_ResolvesRecursively()
{
IOC.Register <RecImportB>(() => { return(new RecImportB()); });
IOC.Register <RecImportA>(() => { return(new RecImportA()); });
IOC.Register <IRecursiveTest>(() => { return(new RecImplA()); });
RecImportB theB = IOC.Resolve <RecImportB>();
Assert.IsNotNull(theB.impA);
Assert.IsNotNull(theB.impA.tstA);
}
public void Setup()
{
IOC.Reset();
lua = new Lua();
luaEnv = lua.CreateEnvironment();
apiBridge = Mock.Interface <IApiBridge>();
IOC.Register <IApiBridge>(() => apiBridge);
IOC.Register <ApiAdapter>(() => new ApiAdapter());
api = IOC.Resolve <ApiAdapter>();
api.LuaEnv = luaEnv;
}
public void GetSingle()
{
//Arange
var ioc = new IOC();
ioc.Register<ICalculateTax>("CompanyATax");
//Act
var calculateTax = ioc.GetSingleByClassName<ICalculateTax>();
//Asert
Assert.IsInstanceOfType(calculateTax, typeof(CompanyATax));
}
public void TestMethod2()
{
//Arange
var ioc = new IOC();
ioc.Register<ICalculateTax>("CompanyATax");
//Act
var calculateTax = ioc.GetList<ICalculateTax>("CompanyATax").ToList();
//Asert
Assert.IsInstanceOfType(calculateTax.First(), typeof(CompanyATax));
}
public void TestMethod1()
{
//Arange
var ioc = new IOC();
//Act
ioc.Register<ICalculateTax>("CompanyATax");
//Asert
Assert.AreEqual(ioc.Items.Count, 1);
}
public void Import(string SharePointSiteUrl, string SharePointUserName, string SharePointPassword, string ImportConfigPath, string TemplateRootFolder)
{
IOC.Register();
container = IOC.GetContainer();
IJsonConverter converter = container.GetInstance <IJsonConverter>();
var mapped = converter.GetConfiguration(ImportConfigPath);
IDeployer deployer = container.GetInstance <IDeployer>();
deployer.Deploy(mapped, TemplateRootFolder, SharePointSiteUrl, SharePointUserName, SharePointPassword);
}
private void Start()
{
m_cache = GetComponentInChildren <IRenderersCache>();
IOC.Register("SelectedRenderers", m_cache);
m_editor = IOC.Resolve <IRTE>();
TryToAddRenderers(m_editor.Selection);
m_editor.Selection.SelectionChanged += OnRuntimeEditorSelectionChanged;
IOC.RegisterFallback <IOutlineManager>(this);
}
protected override void OnEditorExist()
{
if (RenderPipelineInfo.Type != RPType.URP)
{
Destroy(this);
return;
}
base.OnEditorExist();
m_selectionPickerCache = gameObject.AddComponent <RenderersCache>();
IOC.Register <IRenderersCache>("ProBuilder.SelectionPickerCache", m_selectionPickerCache);
PBSelectionPicker.Renderer = new PBSelectionPickerRendererURP(m_selectionPickerCache);
}
private static void RegisterExpDeps()
{
IOC.RegisterFallback(() => Instance.m_gameMachine);
IOC.RegisterFallback(() => Instance.m_appTheme);
IOC.RegisterFallback(() => Instance.m_globalUI);
IOC.RegisterFallback(() => Instance.m_audio);
if (IOC.Resolve <IMenuSelection>() == null)
{
IOC.Register <IMenuSelection>(new MenuSelection());
}
if (IOC.Resolve <IPlayer>() == null)
{
IOC.Register <IPlayer>(new Player());
}
}
protected override void Awake()
{
base.Awake();
IOC.Register <IRTE>(this);
IOC.RegisterFallback(this);
ExposeToEditor[] editorObjects = ExposeToEditor.FindAll(this, ExposeToEditorObjectType.Undefined, false).Select(go => go.GetComponent <ExposeToEditor>()).ToArray();
for (int i = 0; i < editorObjects.Length; ++i)
{
editorObjects[i].ObjectType = ExposeToEditorObjectType.EditorMode;
}
Tools.SnappingMode = SnappingMode.BoundingBox;
IsOpened = !IsInPlayMode;
PlaymodeStateChanged += OnPlaymodeStateChanged;
IsOpenedChanged += OnIsOpenedChanged;
Selection.SelectionChanged += OnRuntimeSelectionChanged;
Tools.ToolChanged += OnRuntimeToolChanged;
Tools.PivotRotationChanged += OnPivotRotationChanged;
Undo.UndoCompleted += OnUndoCompleted;
Undo.RedoCompleted += OnRedoCompleted;
Undo.StateChanged += OnUndoRedoStateChanged;
TransformPanel.SetActive(Selection.activeTransform != null);
if (Prefabs != null && PrefabsPanel != null && PrefabPresenter != null)
{
Prefabs = Prefabs.Where(p => p != null).ToArray();
for (int i = 0; i < Prefabs.Length; ++i)
{
GameObject presenter = Instantiate(PrefabPresenter);
presenter.transform.SetParent(PrefabsPanel.transform);
presenter.transform.position = Vector3.zero;
presenter.transform.localScale = Vector3.one;
InstantiatePrefab instantiatePrefab = presenter.GetComponentInChildren <InstantiatePrefab>();
if (instantiatePrefab != null)
{
instantiatePrefab.Prefab = Prefabs[i];
}
TakeSnapshot takeSnapshot = presenter.GetComponentInChildren <TakeSnapshot>();
if (takeSnapshot != null)
{
takeSnapshot.TargetPrefab = Prefabs[i];
}
}
}
}
protected virtual void AwakeOverride()
{
m_rte = RTE;
IOC.Register <IRTE>(m_rte);
IOC.Register(m_rte);
m_resourcePreview = ResourcePreview;
m_rteAppearance = RTEAppearance;
m_windowManager = WindowManager;
m_console = RuntimeConsole;
m_gameObjectCmd = GameObjectCmd;
m_editCmd = EditCmd;
m_contextMenu = ContextMenu;
m_runtimeHandlesComponent = RuntimeHandlesComponent;
m_editorsMap = EditorsMap;
}
public IocLocator(IOC container)
{
this.container = container;
//var mapper = AutoMapperConfiguration.ConfigureAutoMapper().CreateMapper();
////var mapper = new Mapper(AutoMapperConfiguration.ConfigureAutoMapper());
//container.RegisterSingleton<MapperConfiguration>();
//container.Register<IMapper, Mapper>();
container.RegisterInstance <IMapper>(new Mapper(AutoMapperConfiguration.ConfigureAutoMapper()));
//container.Register(AutoMapperConfiguration.ConfigureAutoMapper().CreateMapper()>
//container.RegisterSingleton<MapperConfiguration>(config);
//container.Register<IMapper>(AutoMapperConfiguration.ConfigureAutoMapper().CreateMapper().);
container.Register <IUnitOfWork, UnitOfWork>();
container.Register <BalanceDietAppContext>();
container.Register <IRecipeLogic, RecipesLogic>();
container.Register <INutritionCalculator, NutririonCalculator>();
container.Register <IRecipeCategoryLogic, RecipeCategoryLogic>();
container.Register <IGenericRepository <Recipe>, Repository <Recipe> >();
container.Register <IGenericRepository <Ingredient>, Repository <Ingredient> >();
container.Register <IGenericRepository <Nutrition>, Repository <Nutrition> >();
container.Register <IGenericRepository <Product>, Repository <Product> >();
}
public ViewModelLocator()
{
container = new IOC();
logicLocator = new IocLocator(container);
container.Register <RecipesListViewModel>();
container.Register <TotalNutritionViewModel>();
container.Register <CurrentCategoryRecipeViewModel>();
container.Register <CategoriesViewModel>();
container.Register <ItemViewModel>();
//var node = container.Resolve<RecipesListViewModel>();
container.Register <MainViewModel>();
}
public void AddFacette_AddsFacetteToCurrentTestContext()
{
var theContext = A.Fake <ITestContext>();
IOC.Reset();
IOC.Register <ITestEnvironment>(() => fakeTev);
IOC.Register <ITestContext>(() => theContext);
var n = typeof(TestyHarness);
Api.CreateFacette("TestFac", new List <object>()
{
1, 2, 3
});
Api.BeginTestCase(n.AssemblyQualifiedName, null);
Api.AddFacette("TestFac", 1, 2);
A.CallTo(() => theContext.AddFacette("TestFac", 1, 2)).MustHaveHappened();
}
private void Start()
{
IOC.Register("HighlightRenderers", m_cache = gameObject.AddComponent <RenderersCache>());
m_editor = IOC.Resolve <IRTE>();
m_activeWindow = m_editor.ActiveWindow;
if (m_activeWindow != null && m_editor.ActiveWindow.WindowType == RuntimeWindowType.Scene)
{
m_selectionComponent = m_activeWindow.IOCContainer.Resolve <IRuntimeSelectionComponent>();
}
m_editor.Object.Enabled += OnObjectEnabled;
m_editor.Object.Disabled += OnObjectDisabled;
m_editor.Object.ComponentAdded += OnComponentAdded;
m_editor.Selection.SelectionChanged += OnSelectionChanged;
m_editor.ActiveWindowChanged += OnActiveWindowChanged;
}
private static void CreateAssetLibraryForScene(Scene scene, int index, AssetLibraryAsset asset, AssetFolderInfo folder, HashSet <UnityObject> hs)
{
TypeMap typeMap = new TypeMap();
AssetDB assetDB = new AssetDB();
IOC.Register <ITypeMap>(typeMap);
IOC.Register <IAssetDB>(assetDB);
PersistentRuntimeScene rtScene = new PersistentRuntimeScene();
GetDepsFromContext ctx = new GetDepsFromContext();
rtScene.GetDepsFrom(scene, ctx);
IOC.Unregister <ITypeMap>(typeMap);
IOC.Unregister <IAssetDB>(assetDB);
CreateAssetLibrary(ctx.Dependencies.ToArray(), "Scenes/" + scene.name, "SceneAssetLibrary", index, asset, folder, hs);
}
static int Main(string[] args)
{
// Setup IOC Container
IOC.Register <IApiBridge>(() => new DefaultApiBridge());
IOC.Register <ITestEnvironment>(() => new TestEnvironment());
IOC.Register <ITestContext>(() => new TestContext());
IOC.Register <Lua>(() => new Lua());
IOC.Register <ApiAdapter>(() => new ApiAdapter());
Write("Mutagen Lua Runner");
Write("Version " + Assembly.GetExecutingAssembly().GetName().Version);
foreach (var str in args)
{
ScriptRunner runner = new ScriptRunner();
runner.Load(new System.IO.FileStream(str, FileMode.Open));
var theResult = runner.Run();
}
return(-1);
}
public void Run_FullTestCase()
{
IOC.Reset();
lua = new Lua();
apiBridge = new DefaultApiBridge();
IOC.Register <IApiBridge>(() => apiBridge);
IOC.Register <ITestEnvironment>(() => new TestEnvironment());
IOC.Register <ITestContext>(() => new MutagenRuntime.TestContext());
IOC.Register <Lua>(() => lua);
IOC.Register <ApiAdapter>(() => new ApiAdapter());
var tc = NUnit.Framework.TestContext.CurrentContext.TestDirectory;
var strm = System.IO.File.OpenRead(tc + "./LuaScripts/FullTestCase.lua");
runner = new ScriptRunner();
IOC.ResolveImports(runner);
// Black Magic: NUnit sets the working dir to a crappy place,
// so we're shit out of luck, if we try to access a file relative to
// our working dir. To get around this problem we magic the correct
// path here and reset the working directory to reflect this:
var dir = AppDomain.CurrentDomain.BaseDirectory;
Environment.CurrentDirectory = dir;
runner.Load(strm);
runner.Run();
var results = Api.GetResults();
Assert.AreEqual(6, results.Count);
var harness = Api.Testharness() as SimpleHarness;
Assert.AreEqual("fnord", harness.lastPrint);
}
public static void ConvertToAsset()
{
const string ext = ";*.rtscene;*.rtprefab;*.rtmat;*.rttex;*.rtmesh;";
if (Application.isPlaying)
{
EditorUtility.DisplayDialog("Unable to load runtime asset", "Unable to load runtime asset in play mode", "OK");
return;
}
string path = EditorUtility.OpenFilePanel("Select Runtime Asset", Application.persistentDataPath, ext);
if (path.Length != 0)
{
GameObject projGo = new GameObject();
IAssetBundleLoader bundleLoader;
#if USE_GOOGLE_DRIVE
if (File.Exists(Application.streamingAssetsPath + "/credentials.json"))
{
bundleLoader = new GoogleDriveAssetBundleLoader();
}
else
#endif
{
bundleLoader = new AssetBundleLoader();
}
IOC.Register(bundleLoader);
ITypeMap typeMap = new TypeMap <long>();
IOC.Register(typeMap);
IUnityObjectFactory objFactory = new UnityObjectFactory();
IOC.Register(objFactory);
ISerializer serializer = new ProtobufSerializer();
IOC.Register(serializer);
IStorage <long> storage = new FileSystemStorage <long>();
IOC.Register(storage);
IRuntimeShaderUtil shaderUtil = new RuntimeShaderUtil();
IOC.Register(shaderUtil);
IMaterialUtil materialUtil = new StandardMaterialUtils();
IOC.Register(materialUtil);
IAssetDB assetDB = new AssetDB();
IOC.Register <IIDMap>(assetDB);
IOC.Register(assetDB);
Project project = projGo.AddComponent <Project>();
project.Awake_Internal();
DirectoryInfo root = new DirectoryInfo(Application.persistentDataPath);
string rootPath = root.ToString().ToLower();
DirectoryInfo parent = Directory.GetParent(path);
while (true)
{
if (parent == null)
{
EditorUtility.DisplayDialog("Unable to load runtime asset", "Project.rtmeta was not found", "OK");
UnityObject.DestroyImmediate(projGo);
IOC.ClearAll();
return;
}
string projectPath = parent.FullName.ToLower();
if (rootPath == projectPath)
{
EditorUtility.DisplayDialog("Unable to load runtime asset", "Project.rtmeta was not found", "OK");
UnityObject.DestroyImmediate(projGo);
IOC.ClearAll();
return;
}
string projectFile = Path.Combine(projectPath, "Project.rtmeta");
if (File.Exists(projectFile))
{
storage.RootPath = Path.GetDirectoryName(projectPath).Replace('\\', '/') + "/";
string projectName = Path.GetFileNameWithoutExtension(projectPath);
project.OpenProject(projectName, (error, result) =>
{
if (error.HasError)
{
EditorUtility.DisplayDialog("Unable to load runtime asset", "Project " + projectName + " can not be loaded", "OK");
UnityObject.DestroyImmediate(projGo);
IOC.ClearAll();
return;
}
string relativePath = GetRelativePath(path, projectPath);
relativePath = relativePath.Replace('\\', '/');
AssetItem assetItem = (AssetItem)project.Root.Get(relativePath);
project.Load(new[] { assetItem }, (loadError, loadedObjects) =>
{
if (loadError.HasError)
{
EditorUtility.DisplayDialog("Unable to load runtime asset", loadError.ToString(), "OK");
}
else
{
if (!project.IsScene(assetItem))
{
foreach (UnityObject asset in assetDB.GetDynamicResources())
{
asset.hideFlags = HideFlags.None;
}
UnityObject loadedObj = loadedObjects[0];
if (loadedObj == null)
{
EditorUtility.DisplayDialog("Unable to load runtime asset", assetItem.Name, "OK");
}
else
{
GameObject loadedGo = loadedObj as GameObject;
if (loadedGo != null)
{
string savePath = EditorUtility.SaveFilePanelInProject("Save " + loadedGo.name, loadedGo.name, "prefab", "Save prefab");
if (!string.IsNullOrWhiteSpace(savePath))
{
PersistentRuntimePrefab <long> runtimePrefab = new PersistentRuntimePrefab <long>();
GetDepsFromContext ctx = new GetDepsFromContext();
runtimePrefab.GetDepsFrom(loadedGo, ctx);
SaveDependencies(ctx, typeMap, assetDB, Path.GetDirectoryName(savePath));
PrefabUtility.SaveAsPrefabAsset(loadedGo, savePath);
}
}
else
{
string savePath = EditorUtility.SaveFilePanelInProject("Save " + loadedObj.name, loadedObj.name, "asset", "Save asset");
if (!string.IsNullOrWhiteSpace(savePath))
{
AssetDatabase.CreateAsset(loadedObj, savePath);
}
}
}
}
}
IOC.ClearAll();
UnityObject.DestroyImmediate(projGo);
});
});
return;
}
parent = parent.Parent;
}
}
}
public static void OpenScene()
{
if (Application.isPlaying)
{
EditorUtility.DisplayDialog("Unable to open scene", "Unable to open scene in play mode", "OK");
return;
}
string path = EditorUtility.OpenFilePanel("Open Scene", Application.persistentDataPath, "rtscene");
if (path.Length != 0)
{
GameObject projGo = new GameObject();
IAssetBundleLoader bundleLoader;
if (File.Exists(Application.streamingAssetsPath + "/credentials.json"))
{
bundleLoader = new GoogleDriveAssetBundleLoader();
}
else
{
bundleLoader = new AssetBundleLoader();
}
IOC.Register(bundleLoader);
ITypeMap typeMap = new TypeMap();
IOC.Register(typeMap);
IUnityObjectFactory objFactory = new UnityObjectFactory();
IOC.Register(objFactory);
ISerializer serializer = new ProtobufSerializer();
IOC.Register(serializer);
IStorage storage = new FileSystemStorage();
IOC.Register(storage);
IRuntimeShaderUtil shaderUtil = new RuntimeShaderUtil();
IOC.Register(shaderUtil);
IAssetDB assetDB = new AssetDB();
IOC.Register <IIDMap>(assetDB);
IOC.Register(assetDB);
Project project = projGo.AddComponent <Project>();
project.Awake_Internal();
DirectoryInfo root = new DirectoryInfo(Application.persistentDataPath);
string rootPath = root.ToString().ToLower();
DirectoryInfo parent = Directory.GetParent(path);
while (true)
{
if (parent == null)
{
EditorUtility.DisplayDialog("Unable to open scene", "Project.rtmeta was not found", "OK");
UnityObject.DestroyImmediate(projGo);
IOC.ClearAll();
return;
}
string projectPath = parent.FullName.ToLower();
if (rootPath == projectPath)
{
EditorUtility.DisplayDialog("Unable to open scene", "Project.rtmeta was not found", "OK");
UnityObject.DestroyImmediate(projGo);
IOC.ClearAll();
return;
}
string projectFile = Path.Combine(projectPath, "Project.rtmeta");
if (File.Exists(projectFile))
{
string projectFileName = Path.GetFileNameWithoutExtension(projectPath);
project.OpenProject(projectFileName, (error, result) =>
{
if (error.HasError)
{
EditorUtility.DisplayDialog("Unable to open scene", "Project " + projectFileName + " can not be loaded", "OK");
UnityObject.DestroyImmediate(projGo);
IOC.ClearAll();
return;
}
string relativePath = GetRelativePath(path, projectPath);
relativePath = relativePath.Replace('\\', '/');
AssetItem scene = (AssetItem)project.Root.Get(relativePath);
project.Load(new[] { scene }, (loadError, loadedObjects) =>
{
IOC.ClearAll();
if (loadError.HasError)
{
EditorUtility.DisplayDialog("Unable to open scene", loadError.ToString(), "OK");
UnityObject.DestroyImmediate(projGo);
return;
}
});
});
return;
}
parent = parent.Parent;
}
}
}
private void OnEnable()
{
IOC.Register("TerrainLayerEditor", this);
}
private static void CreateAssetLibraryFromScene(Scene scene, int index, AssetLibraryAsset asset, AssetFolderInfo folder, HashSet <UnityObject> hs)
{
TypeMap typeMap = new TypeMap();
AssetDB assetDB = new AssetDB();
IOC.Register <ITypeMap>(typeMap);
IOC.Register <IAssetDB>(assetDB);
PersistentRuntimeScene rtScene = new PersistentRuntimeScene();
GetDepsFromContext ctx = new GetDepsFromContext();
rtScene.GetDepsFrom(scene, ctx);
IOC.Unregister <ITypeMap>(typeMap);
IOC.Unregister <IAssetDB>(assetDB);
int identity = asset.AssetLibrary.Identity;
foreach (UnityObject obj in ctx.Dependencies)
{
if (hs.Contains(obj))
{
continue;
}
if (obj is GameObject)
{
GameObject go = (GameObject)obj;
if (go.IsPrefab())
{
AssetInfo assetInfo = new AssetInfo(go.name, 0, identity);
assetInfo.Object = go;
identity++;
List <PrefabPartInfo> prefabParts = new List <PrefabPartInfo>();
AssetLibraryAssetsGUI.CreatePefabParts(go, ref identity, prefabParts);
if (prefabParts.Count >= AssetLibraryInfo.MAX_ASSETS - AssetLibraryInfo.INITIAL_ID)
{
EditorUtility.DisplayDialog("Unable Create AssetLibrary", string.Format("Max 'Indentity' value reached. 'Identity' == {0}", AssetLibraryInfo.MAX_ASSETS), "OK");
return;
}
if (identity >= AssetLibraryInfo.MAX_ASSETS)
{
SaveAssetLibrary(asset, scene, index);
index++;
asset = ScriptableObject.CreateInstance <AssetLibraryAsset>();
folder = asset.AssetLibrary.Folders.Where(f => f.depth == 0).First();
identity = asset.AssetLibrary.Identity;
}
assetInfo.PrefabParts = prefabParts;
asset.AssetLibrary.Identity = identity;
folder.Assets.Add(assetInfo);
}
}
else
{
AssetInfo assetInfo = new AssetInfo(obj.name, 0, identity);
assetInfo.Object = obj;
identity++;
if (identity >= AssetLibraryInfo.MAX_ASSETS)
{
SaveAssetLibrary(asset, scene, index);
index++;
asset = ScriptableObject.CreateInstance <AssetLibraryAsset>();
folder = asset.AssetLibrary.Folders.Where(f => f.depth == 0).First();
identity = asset.AssetLibrary.Identity;
}
asset.AssetLibrary.Identity = identity;
folder.Assets.Add(assetInfo);
}
}
SaveAssetLibrary(asset, scene, index);
index++;
Selection.activeObject = asset;
EditorGUIUtility.PingObject(asset);
}
