示例#1
0
        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));
        }
示例#2
0
        public void GetSingle()
        {
            //Arange
            var ioc = new IOC();
            ioc.Register<ICalculateTax>("CompanyATax");

            //Act
            var calculateTax = ioc.GetSingleByClassName<ICalculateTax>();

            //Asert
            Assert.IsInstanceOfType(calculateTax, typeof(CompanyATax));
        }
示例#3
0
        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);
        }
示例#6
0
        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);
            }
        }
示例#8
0
        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;
        }
示例#9
0
 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;
                }
            }
        }
示例#13
0
        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);
            }
        }
示例#14
0
        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);
        }
示例#16
0
        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);
        }
示例#17
0
        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());
            }
        }
示例#19
0
        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);
        }
示例#21
0
        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();
        }
示例#22
0
        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);
        }
示例#23
0
        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"),
            });
        }
示例#25
0
        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);
            }
        }
示例#27
0
        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);
        }
示例#28
0
        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));
        }
示例#29
0
        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);
            });
        }
示例#31
0
        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;
            }
        }
示例#32
0
        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);
        }
示例#34
0
        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);
        }