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 GetSingle() { //Arange var ioc = new IOC(); ioc.Register<ICalculateTax>("CompanyATax"); //Act var calculateTax = ioc.GetSingleByClassName<ICalculateTax>(); //Asert Assert.IsInstanceOfType(calculateTax, typeof(CompanyATax)); }
public void TestMethod1() { //Arange var ioc = new IOC(); //Act ioc.Register<ICalculateTax>("CompanyATax"); //Asert Assert.AreEqual(ioc.Items.Count, 1); }
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)); }
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); }
private void OnSelect() { ISelectObjectDialog objectSelector = null; Transform dialogTransform = IOC.Resolve <IWindowManager>().CreateDialogWindow(RuntimeWindowType.SelectObject.ToString(), "Select " + MemberInfoType.Name, (sender, args) => { if (objectSelector.IsNoneSelected) { SetValue(null); EndEdit(); SetInputField(null); } else { SetValue(objectSelector.SelectedObject); EndEdit(); SetInputField(objectSelector.SelectedObject); } }); objectSelector = IOC.Resolve <ISelectObjectDialog>();// dialogTransform.GetComponentInChildren<SelectObjectDialog>(); objectSelector.ObjectType = MemberInfoType; }
protected virtual void OnEnable() { Camera camera = Window.Camera; IRTEGraphicsLayer graphicsLayer = Window.IOCContainer.Resolve <IRTEGraphicsLayer>(); if (graphicsLayer != null) { camera = graphicsLayer.Camera.Camera; } IRTEGraphics graphics = IOC.Resolve <IRTEGraphics>(); m_rteCamera = graphics.CreateCamera(camera, CameraEvent.AfterImageEffects, false, true); m_rteCamera.RenderersCache.Add(m_output.GetComponent <Renderer>()); m_rteCamera.RefreshCommandBuffer(); DoSceneGizmo(); if (BtnProjection != null) { BtnProjection.gameObject.SetActive(true); } }
private void Awake() { m_editor = IOC.Resolve <IRTE>(); m_editor.Tools.ToolChanged += OnEditorToolChanged; m_editor.Selection.SelectionChanged += OnEditorSelectionChanged; IOC.RegisterFallback <IMeshDeformerTool>(this); GameObject controlPointPicker = new GameObject("ControlPointPicker"); controlPointPicker.transform.SetParent(transform, false); controlPointPicker.gameObject.SetActive(false); controlPointPicker.hideFlags = HideFlags.HideInHierarchy; ExposeToEditor exposeToEditor = controlPointPicker.AddComponent <ExposeToEditor>(); exposeToEditor.CanInspect = false; controlPointPicker.gameObject.SetActive(true); m_controlPointPicker = controlPointPicker.AddComponent <ControlPointPicker>(); m_controlPointPicker.SelectionChanged += OnPickerSelectionChanged; Deformer.Refreshed += OnDeformerRefreshed; }
private void OnRuntimeSelectionChanged(UnityObject[] unselectedObjects) { if (m_editor != null && unselectedObjects != null && unselectedObjects.Length > 0) { IRuntimeEditor editor = IOC.Resolve <IRuntimeEditor>(); if (editor.IsDirty) { editor.IsDirty = false; editor.SaveAsset(unselectedObjects[0], result => { CreateEditor(); }); } else { CreateEditor(); } } else { CreateEditor(); } }
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converter) { ILocalization lc = IOC.Resolve <ILocalization>(); MemberInfo clipInfo = Strong.PropertyInfo((AudioSource x) => x.clip, "clip"); MemberInfo volumeInfo = Strong.PropertyInfo((AudioSource x) => x.volume, "volume"); MemberInfo loopInfo = Strong.PropertyInfo((AudioSource x) => x.loop, "loop"); MemberInfo playOnAwake = Strong.PropertyInfo((AudioSource x) => x.playOnAwake, "playOnAwake"); return(new[] { new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_AudioSource_Loop", "Loop"), editor.Component, loopInfo), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_AudioSource_PlayOnAwake", "Play On Awake"), editor.Component, playOnAwake), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_AudioSource_Clip", "Clip"), editor.Component, clipInfo), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_AudioSource_Volume", "Volume"), editor.Component, volumeInfo, volumeInfo, null, new Range(0.0f, 1.0f)) { AnimationPropertyName = "m_Volume" }, }); }
private void Register() { ILocalization lc = IOC.Resolve <ILocalization>(); lc.LoadStringResources("RTScripting.StringResources"); IWindowManager wm = IOC.Resolve <IWindowManager>(); if (m_editRuntimeScriptDialog != null) { RegisterWindow(wm, "EditRuntimeScript", lc.GetString("ID_RTScripting_WM_Header_EditScript", "Edit Script"), Resources.Load <Sprite>("RTE_Script"), m_editRuntimeScriptDialog, true); IRTEAppearance appearance = IOC.Resolve <IRTEAppearance>(); appearance.ApplyColors(m_editRuntimeScriptDialog); } if (m_runtimeScriptEditor != null) { IEditorsMap map = IOC.Resolve <IEditorsMap>(); map.RegisterEditor(m_runtimeScriptEditor); } }
private void UpdateContextMenuHandler() { IProjectFolder projectFolder = IOC.Resolve <IProjectFolder>(); if (m_projectFolder != projectFolder) { if (m_projectFolder != null) { m_projectFolder.ItemOpen -= OnProjectFolderItemOpen; m_projectFolder.ValidateContextMenuOpenCommand -= OnProjectFolderValidateContextMenuOpenCommand; m_projectFolder.ContextMenu -= OnProjectFolderContextMenu; } m_projectFolder = projectFolder; if (m_projectFolder != null) { m_projectFolder.ItemOpen += OnProjectFolderItemOpen; m_projectFolder.ValidateContextMenuOpenCommand += OnProjectFolderValidateContextMenuOpenCommand; m_projectFolder.ContextMenu += OnProjectFolderContextMenu; } } }
static void Main(string[] args) { try { string path = ""; string stroka = ""; int count = 0; IOF iof = new IOF(); IOC ioc = new IOC(); Symbol symbol = new Symbol(); Sentence sentence = new Sentence(); Text text = new Text(); path = ioc.Messeges(path); stroka = iof.Read(path); ioc.Output(stroka); do { count = ioc.OutputMenu(); switch (count) { case 1: text.DeleteSpaces(stroka); Console.WriteLine(text); sentence.Processing(stroka); break; case 0: return; } } while (count != 0); } catch (Exception e) { Console.WriteLine(e); } }
public async void RunCompilerAsync(string[] scripts, ProjectAsyncOperation ao) { #if UNITY_STANDALONE ICompiler compiler = IOC.Resolve <ICompiler>(); #endif try { byte[] binData = null; #if UNITY_STANDALONE binData = await Task.Run(() => compiler.Compile(scripts)); #endif if (binData == null) { RaiseCompiled(false); ao.Error = new Error(Error.E_Failed) { ErrorText = m_localization.GetString("ID_RTScripting_ScriptsManager_CompilationFailed", "Compilation failed") }; ao.IsCompleted = true; } else { StartCoroutine(CoSaveAssembly(binData, ao)); } } catch (Exception e) { RaiseCompiled(false); ao.Error = new Error(Error.E_Exception) { ErrorText = e.ToString() }; ao.IsCompleted = true; } }
public void TestDiscount() { IOC.IntegrationTest(); IOC.SettingsService.ExclVat(); IOC.VatCalculationStrategy.OverParts(); var productDiscountPercentage = DefaultFactoriesAndSharedFunctionality.CreateProductDiscountPercentage(17); var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(2456, 5, 20m, productDiscountPercentage); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50); DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(order, discount); var line = order.OrderLines.Single(); Assert.AreEqual(2038, productInfo.PriceInCents); Assert.AreEqual(2446, productInfo.PriceWithVatInCents); Assert.AreEqual(408, productInfo.VatAmountInCents); Assert.AreEqual(2446 * 5, line.AmountInCents); Assert.AreEqual(2446 * 5, line.GrandTotalInCents); Assert.AreEqual(2038 * 5, line.SubTotalInCents); Assert.AreEqual(408 * 5, line.VatAmountInCents); // todo: commented lines need to be adjusted for discount on order lvl //Assert.AreEqual(2038 / 2, productInfo.OrderPriceInCents); //Assert.AreEqual(2446 / 2, productInfo.OrderPriceWithVatInCents); //Assert.AreEqual(408 / 2, productInfo.OrderVatAmountInCents); //Assert.AreEqual(2038 * 5 / 2, line.OrderAmountInCents); //Assert.AreEqual(2446 * 5 / 2, line.OrderAmountWithVatInCents); //Assert.AreEqual(2038 * 5 / 2, line.OrderAmountWithoutInCents); //Assert.AreEqual(408 * 5 / 2, line.OrderVatAmountInCents); //Assert.AreEqual(408 * 5 / 2, line.OrderLineVatAmountAfterOrderDiscountInCents); Assert.AreEqual(408 * 5 / 2, order.VatTotalInCents); Assert.AreEqual(2446 * 5 / 2, order.GrandtotalInCents); Assert.AreEqual(2038 * 5 / 2, order.SubtotalInCents); }
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 override void GetDepsFrom(object obj, GetDepsFromContext context) { base.GetDepsFrom(obj, context); if (obj == null) { return; } Material o = (Material)obj; AddDep(o.shader, context); RuntimeShaderInfo shaderInfo = null; IRuntimeShaderUtil shaderUtil = IOC.Resolve <IRuntimeShaderUtil>(); if (shaderUtil != null) { shaderInfo = shaderUtil.GetShaderInfo(o.shader); } if (shaderInfo == null) { return; } for (int i = 0; i < shaderInfo.PropertyCount; ++i) { string name = shaderInfo.PropertyNames[i]; RTShaderPropertyType type = shaderInfo.PropertyTypes[i]; switch (type) { case RTShaderPropertyType.TexEnv: AddDep(o.GetTexture(name), context); break; } } }
protected virtual void OnItemClick(object sender, ItemArgs e) { if (e.PointerEventData.button == PointerEventData.InputButton.Right) { IContextMenu menu = IOC.Resolve <IContextMenu>(); List <MenuItemInfo> menuItems = new List <MenuItemInfo>(); MenuItemInfo duplicate = new MenuItemInfo { Path = m_localization.GetString("ID_RTEditor_HierarchyViewImpl_Duplicate", "Duplicate") }; duplicate.Action = new MenuItemEvent(); duplicate.Action.AddListener(DuplicateContextMenuCmd); duplicate.Validate = new MenuItemValidationEvent(); duplicate.Validate.AddListener(DuplicateValidateContextMenuCmd); menuItems.Add(duplicate); MenuItemInfo delete = new MenuItemInfo { Path = m_localization.GetString("ID_RTEditor_HierarchyViewImpl_Delete", "Delete") }; delete.Action = new MenuItemEvent(); delete.Action.AddListener(DeleteContextMenuCmd); delete.Validate = new MenuItemValidationEvent(); delete.Validate.AddListener(DeleteValidateContextMenuCmd); menuItems.Add(delete); MenuItemInfo rename = new MenuItemInfo { Path = m_localization.GetString("ID_RTEditor_HierarchyViewImpl_Rename", "Rename") }; rename.Action = new MenuItemEvent(); rename.Action.AddListener(RenameContextMenuCmd); rename.Validate = new MenuItemValidationEvent(); rename.Validate.AddListener(RenameValidateContextMenuCmd); menuItems.Add(rename); menu.Open(menuItems.ToArray()); } }
protected override void AwakeOverride() { WindowType = RuntimeWindowType.ProjectTree; base.AwakeOverride(); if (Editor == null) { Debug.LogError("Editor is null"); return; } if (TreeViewPrefab == null) { Debug.LogError("TreeViewPrefab is null"); return; } m_project = IOC.Resolve <IProject>(); m_treeView = Instantiate(TreeViewPrefab).GetComponent <VirtualizingTreeView>(); m_treeView.CanReorder = false; m_treeView.CanReparent = ShowRootFolder; m_treeView.CanUnselectAll = false; m_treeView.CanDrag = ShowRootFolder; m_treeView.CanRemove = false; m_treeView.transform.SetParent(transform, false); m_treeView.SelectionChanged += OnSelectionChanged; m_treeView.ItemDataBinding += OnItemDataBinding; m_treeView.ItemExpanding += OnItemExpanding; m_treeView.ItemsRemoving += OnItemsRemoving; m_treeView.ItemsRemoved += OnItemsRemoved; m_treeView.ItemBeginEdit += OnItemBeginEdit; m_treeView.ItemEndEdit += OnItemEndEdit; m_treeView.ItemBeginDrop += OnItemBeginDrop; m_treeView.ItemDrop += OnItemDrop; m_treeView.ItemDoubleClick += OnItemDoubleClick; }
public ProjectAsyncOperation <T> GetValue <T>(string key, ProjectEventHandler <T> callback = null) { ProjectAsyncOperation <T> ao = new ProjectAsyncOperation <T>(); ITypeMap typeMap = IOC.Resolve <ITypeMap>(); Type persistentType = typeMap.ToPersistentType(typeof(T)); if (persistentType == null || !PlayerPrefs.HasKey(key)) { ao.Error = new Error(Error.E_NotFound); if (callback != null) { callback(ao.Error, default(T)); } ao.IsCompleted = true; } else { string data = PlayerPrefs.GetString(key); byte[] bytes = Convert.FromBase64String(data); ISerializer serializer = IOC.Resolve <ISerializer>(); PersistentSurrogate surrogate = (PersistentSurrogate)serializer.Deserialize(bytes, persistentType); T obj = (T)surrogate.Instantiate(typeof(T)); surrogate.WriteTo(obj); ao.Result = obj; ao.Error = Error.NoError; if (callback != null) { callback(ao.Error, ao.Result); } ao.IsCompleted = true; } return(ao); }
public override void Drop(object[] dragObjects, PointerEventData pointerEventData) { base.Drop(dragObjects, pointerEventData); ProjectItem dropTarget = (ProjectItem)m_treeView.DropTarget; if (CanDrop(dropTarget, dragObjects)) { Editor.IsBusy = true; m_project.Move(dragObjects.OfType <ProjectItem>().ToArray(), dropTarget, (error, arg1, arg2) => Editor.IsBusy = false); } else if (dropTarget != null && dropTarget.IsFolder && CanCreatePrefab(dropTarget, dragObjects)) { IRuntimeEditor editor = IOC.Resolve <IRuntimeEditor>(); ExposeToEditor dragObject = (ExposeToEditor)dragObjects[0]; if (dropTarget.IsFolder) { editor.CreatePrefab(dropTarget, dragObject, null, assetItem => { }); } } m_treeView.ExternalItemDrop(); }
public void GetPreviews(string projectPath, string[] folderPath, string searchPattern, StorageEventHandler <Preview[][]> callback) { projectPath = FullPath(projectPath); ISerializer serializer = IOC.Resolve <ISerializer>(); Preview[][] result = new Preview[folderPath.Length][]; for (int i = 0; i < folderPath.Length; ++i) { string path = projectPath + folderPath[i]; if (!Directory.Exists(path)) { continue; } if (searchPattern == null) { searchPattern = string.Empty; } else { searchPattern = searchPattern.Replace("..", "."); } string[] files = Directory.GetFiles(path, string.Format("*{0}*{1}", searchPattern, PreviewExt)); Preview[] previews = new Preview[files.Length]; for (int j = 0; j < files.Length; ++j) { previews[j] = Load <Preview>(serializer, files[j]); } result[i] = previews; } callback(new Error(), result); }
private void GetProjectTree(string path, ProjectItem parent) { if (!Directory.Exists(path)) { return; } ISerializer serializer = IOC.Resolve <ISerializer>(); string[] dirs = Directory.GetDirectories(path); for (int i = 0; i < dirs.Length; ++i) { string dir = dirs[i]; ProjectItem projectItem = LoadItem <ProjectItem>(serializer, dir + MetaExt); projectItem.Parent = parent; projectItem.Children = new List <ProjectItem>(); parent.Children.Add(projectItem); GetProjectTree(dir, projectItem); } string[] files = Directory.GetFiles(path, "*" + MetaExt); for (int i = 0; i < files.Length; ++i) { string file = files[i]; if (!File.Exists(file.Replace(MetaExt, string.Empty))) { continue; } AssetItem assetItem = LoadItem <AssetItem>(serializer, file); assetItem.Parent = parent; parent.Children.Add(assetItem); } }
public override PropertyDescriptor[] GetProperties(ComponentEditor editor, object converterObj) { ILocalization lc = IOC.Resolve <ILocalization>(); CapsuleColliderPropertyConverter converter = (CapsuleColliderPropertyConverter)converterObj; MemberInfo isTriggerInfo = Strong.PropertyInfo((CapsuleCollider x) => x.isTrigger, "isTrigger"); MemberInfo materialInfo = Strong.PropertyInfo((CapsuleCollider x) => x.sharedMaterial, "sharedMaterial"); MemberInfo centerInfo = Strong.PropertyInfo((CapsuleCollider x) => x.center, "center"); MemberInfo radiusInfo = Strong.PropertyInfo((CapsuleCollider x) => x.radius, "radius"); MemberInfo heightInfo = Strong.PropertyInfo((CapsuleCollider x) => x.height, "height"); MemberInfo directionInfo = Strong.PropertyInfo((CapsuleCollider x) => x.direction, "direction"); MemberInfo directionConvertedInfo = Strong.PropertyInfo((CapsuleColliderPropertyConverter x) => x.Direction, "Direction"); return(new[] { new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_CapsuleCollider_IsTrigger", "Is Trigger"), editor.Component, isTriggerInfo, "m_IsTrigger"), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_CapsuleCollider_Material", "Material"), editor.Component, materialInfo), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_CapsuleCollider_Center", "Center"), editor.Component, centerInfo, "m_Center"), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_CapsuleCollider_Radius", "Radius"), editor.Component, radiusInfo, "m_Radius"), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_CapsuleCollider_Height", "Height"), editor.Component, heightInfo, "m_Height"), new PropertyDescriptor(lc.GetString("ID_RTEditor_CD_CapsuleCollider_Direction", "Direction"), converter, directionConvertedInfo, "m_Direction"), }); }
private object OnNewShape(object arg) { GameObject go = PBShapeGenerator.CreateShape((PBShapeType)arg); go.AddComponent <PBMesh>(); Renderer renderer = go.GetComponent <Renderer>(); if (renderer != null && renderer.sharedMaterials.Length == 1 && renderer.sharedMaterials[0] == PBBuiltinMaterials.DefaultMaterial) { IMaterialPaletteManager paletteManager = IOC.Resolve <IMaterialPaletteManager>(); if (paletteManager.Palette.Materials.Count > 0) { renderer.sharedMaterial = paletteManager.Palette.Materials[0]; } } IRuntimeEditor rte = IOC.Resolve <IRuntimeEditor>(); RuntimeWindow scene = rte.GetWindow(RuntimeWindowType.Scene); Vector3 position; Quaternion rotation; GetPositionAndRotation(scene, out position, out rotation); ExposeToEditor exposeToEditor = go.AddComponent <ExposeToEditor>(); go.transform.position = position + rotation * Vector3.up * exposeToEditor.Bounds.extents.y; go.transform.rotation = rotation; Editor.Undo.BeginRecord(); Editor.Selection.activeGameObject = go; Editor.Undo.RegisterCreatedObjects(new[] { exposeToEditor }); Editor.Undo.EndRecord(); return(go); }
private void Start() { if (RenderPipelineInfo.Type != RPType.Standard) { //Debug.Log("OutlineManager is not supported"); Destroy(this); return; } m_outlineEffect = Camera.gameObject.AddComponent <OutlineEffect>(); m_editor = IOC.Resolve <IRTE>(); TryToAddRenderers(m_editor.Selection); m_editor.Selection.SelectionChanged += OnRuntimeEditorSelectionChanged; RTEComponent rteComponent = GetComponentInParent <RTEComponent>(); if (rteComponent != null) { m_sceneWindow = rteComponent.Window; m_sceneWindow.IOCContainer.RegisterFallback <IOutlineManager>(this); } }
public void Load(string projectPath, string[] assetPaths, Type[] types, StorageEventHandler <PersistentObject[]> callback) { PersistentObject[] result = new PersistentObject[assetPaths.Length]; for (int i = 0; i < assetPaths.Length; ++i) { string assetPath = assetPaths[i]; assetPath = FullPath(projectPath) + assetPath; ISerializer serializer = IOC.Resolve <ISerializer>(); try { if (File.Exists(assetPath)) { using (FileStream fs = File.OpenRead(assetPath)) { result[i] = (PersistentObject)serializer.Deserialize(fs, types[i]); } } else { callback(new Error(Error.E_NotFound), new PersistentObject[0]); return; } } catch (Exception e) { Debug.LogErrorFormat("Unable to load asset: {0} -> got exception: {1} ", assetPath, e.ToString()); callback(new Error(Error.E_Exception) { ErrorText = e.ToString() }, new PersistentObject[0]); return; } } callback(new Error(Error.OK), result); }
public void Save(string projectPath, AssetBundleInfo assetBundleInfo, ProjectInfo projectInfo, StorageEventHandler callback) { projectPath = FullPath(projectPath); string projectInfoPath = projectPath + "/Project.rtmeta"; string assetBundlePath = assetBundleInfo.UniqueName.Replace("/", "_").Replace("\\", "_"); assetBundlePath += ".rtbundle"; assetBundlePath = projectPath + "/" + assetBundlePath; ISerializer serializer = IOC.Resolve <ISerializer>(); using (FileStream fs = File.OpenWrite(assetBundlePath)) { serializer.Serialize(assetBundleInfo, fs); } using (FileStream fs = File.OpenWrite(projectInfoPath)) { serializer.Serialize(projectInfo, fs); } callback(new Error(Error.OK)); }
private void Awake() { m_editor = IOC.Resolve <IRuntimeEditor>(); m_editor.Object.ComponentAdded += OnComponentAdded; m_editorsMap = IOC.Resolve <IEditorsMap>(); GameObject go = m_editor.Selection.activeGameObject; HashSet <Component> ignoreComponents = IgnoreComponents(go); InputName.text = go.name; // InputName.readOnly = true; TogEnableDisable.isOn = go.activeSelf; InputName.onEndEdit.AddListener(OnEndEditName); TogEnableDisable.onValueChanged.AddListener(OnEnableDisable); Component[] components = go.GetComponents <Component>(); for (int i = 0; i < components.Length; ++i) { Component component = components[i]; CreateComponentEditor(go, component, ignoreComponents); } }
private void OnFlatten() { Terrain terrain = TerrainEditor.Terrain; if (terrain == null) { return; } float[,] oldHeightmap = GetHeightmap(); float[,] newHeightmap = GetHeightmap(); int w = newHeightmap.GetLength(0); int h = newHeightmap.GetLength(1); float heightmapScale = terrain.terrainData.heightmapScale.y; for (int i = 0; i < w; ++i) { for (int j = 0; j < w; ++j) { newHeightmap[i, j] = Height / heightmapScale; } } terrain.SetHeights(0, 0, newHeightmap); IRTE editor = IOC.Resolve <IRTE>(); editor.Undo.CreateRecord(record => { terrain.SetHeights(0, 0, newHeightmap); return(true); }, record => { terrain.SetHeights(0, 0, oldHeightmap); return(true); }); }
public void Exec(string cmd) { cmd = cmd.ToLower(); switch (cmd) { case "duplicate": m_editor.Duplicate(m_editor.Selection.gameObjects); break; case "delete": m_editor.Delete(m_editor.Selection.gameObjects); break; case "undo": m_editor.Undo.Undo(); break; case "redo": m_editor.Undo.Redo(); break; case "play": m_editor.IsPlaying = true; break; case "stop": m_editor.IsPlaying = false; break; case "settings": IWindowManager wm = IOC.Resolve <IWindowManager>(); wm.CreateDialogWindow("settings", "Settings", (sender, args) => { }, (sender, args) => { }, 350, 350, 350, 350, false); break; } }
private void Start() { m_editor = IOC.Resolve <IRuntimeEditor>(); m_editor.Undo.UndoCompleted += OnUndoCompleted; m_editor.Undo.RedoCompleted += OnRedoCompleted; m_resourcePreviewUtility = IOC.Resolve <IResourcePreviewUtility>(); m_editorsMap = IOC.Resolve <IEditorsMap>(); if (Material == null) { Material = m_editor.Selection.activeObject as Material; } if (Material == null) { Debug.LogError("Select material"); return; } m_previewTexture = new Texture2D(1, 1, TextureFormat.ARGB32, true); TxtMaterialName.text = Material.name; if (Material.shader != null) { TxtShaderName.text = Material.shader.name; } else { TxtShaderName.text = "Shader missing"; } UpdatePreview(Material); BuildEditor(); }
protected override void OnDestroyOverride() { base.OnDestroyOverride(); if (m_listBox != null) { m_listBox.ItemDataBinding -= OnItemDataBinding; m_listBox.ItemBeginDrag -= OnItemBeginDrag; m_listBox.ItemDragEnter -= OnItemDragEnter; m_listBox.ItemDrag -= OnItemDrag; m_listBox.ItemDragExit -= OnItemDragExit; m_listBox.ItemDrop -= OnItemDrop; m_listBox.ItemEndDrag -= OnItemEndDrag; m_listBox.ItemsRemoving -= OnItemRemoving; m_listBox.ItemsRemoved -= OnItemRemoved; m_listBox.ItemDoubleClick -= OnItemDoubleClick; m_listBox.ItemBeginEdit -= OnItemBeginEdit; m_listBox.ItemEndEdit -= OnItemEndEdit; m_listBox.ItemClick -= OnItemClick; m_listBox.Click -= OnListBoxClick; m_listBox.SelectionChanged -= OnSelectionChanged; } if (Editor != null) { Editor.Selection.SelectionChanged -= EditorSelectionChanged; } if (Destroyed != null) { Destroyed(this, EventArgs.Empty); } IOC.UnregisterFallback <IProjectFolder>(this); }
private void CreatePrefabWithDependencies(ProjectItem dropTarget, ExposeToEditor dragObject, Action <AssetItem[]> done) { IResourcePreviewUtility previewUtility = IOC.Resolve <IResourcePreviewUtility>(); m_project.GetDependencies(dragObject.gameObject, true, (error, deps) => { object[] objects; if (!deps.Contains(dragObject.gameObject)) { Debug.Log(dragObject.gameObject); objects = new object[deps.Length + 1]; objects[deps.Length] = dragObject.gameObject; for (int i = 0; i < deps.Length; ++i) { objects[i] = deps[i]; } } else { objects = deps; } IUnityObjectFactory uoFactory = IOC.Resolve <IUnityObjectFactory>(); objects = objects.Where(obj => uoFactory.CanCreateInstance(obj.GetType())).ToArray(); byte[][] previewData = new byte[objects.Length][]; for (int i = 0; i < objects.Length; ++i) { if (objects[i] is UnityObject) { previewData[i] = previewUtility.CreatePreviewData((UnityObject)objects[i]); } } CreatePrefab(dropTarget, previewData, objects, done); }); }
protected virtual void OnDestroy() { if (m_treeView != null) { m_treeView.SelectionChanged -= OnSelectionChanged; m_treeView.ItemDataBinding -= OnItemDataBinding; m_treeView.ItemExpanding -= OnItemExpanding; m_treeView.ItemsRemoving -= OnItemsRemoving; m_treeView.ItemsRemoved -= OnItemsRemoved; m_treeView.ItemBeginEdit -= OnItemBeginEdit; m_treeView.ItemEndEdit -= OnItemEndEdit; m_treeView.ItemBeginDrag -= OnItemBeginDrag; m_treeView.ItemBeginDrop -= OnItemBeginDrop; m_treeView.ItemDragEnter -= OnItemDragEnter; m_treeView.ItemDrag -= OnItemDrag; m_treeView.ItemDragExit -= OnItemDragExit; m_treeView.ItemDrop -= OnItemDrop; m_treeView.ItemEndDrag -= OnItemEndDrag; m_treeView.ItemDoubleClick -= OnItemDoubleClick; m_treeView.ItemClick -= OnItemClick; } if (m_projectTreeView != null) { m_projectTreeView.DragEnterEvent -= OnDragEnter; m_projectTreeView.DragLeaveEvent -= OnDragLeave; m_projectTreeView.DragEvent -= OnDrag; m_projectTreeView.DropEvent -= OnDrop; } if (Destroyed != null) { Destroyed(this, EventArgs.Empty); } IOC.UnregisterFallback <IProjectTree>(this); }