예제 #1
0
        private BaseEditor GetObjectUnderMouse(Ray mouseRay, bool pickWidgets, bool pickTerrain)
        {
            Mogre.Entity        result;
            Mogre.Vector3       hitLocation   = new Mogre.Vector3();
            Mogre.RaySceneQuery raySceneQuery = MogitorsRoot.Instance.SceneManager.CreateRayQuery(new Mogre.Ray());
            BaseEditor          selected      = null;

            AxisType editorAxis = AxisType.None;

            if (pickWidgets && MogitorsRoot.Instance.PickGizmos(mouseRay, ref editorAxis))
            {
                selected   = MogitorsRoot.Instance.Selected;
                EditorAxis = editorAxis;
            }
            else
            {
                raySceneQuery.QueryMask = ~QueryFlags.Widget;
                if (MogitorsRoot.Instance.PickEntity(raySceneQuery, mouseRay, out result, hitLocation, "", -1.0f) && result.Name != "HydraxMeshEnt")
                {
                    selected = MogitorsRoot.Instance.FindObject(result.Name, 0);
                }
            }
            MogitorsRoot.Instance.SceneManager.DestroyQuery(raySceneQuery);
            return(selected);
        }
예제 #2
0
        public override BaseEditor CreateObject(ref BaseEditor parent, NameValuePairList parameters)
        {
            ViewportEditor obj = new ViewportEditor();

            Mogre.NameValuePairList.Iterator ni;
            if ((ni = parameters.Find("ViewportIndex")) != parameters.End())
            {
                obj.ViewportIndex = (uint)Mogre.StringConverter.ParseInt(ni.Value);
                if (lastZOrder < obj.ViewportIndex)
                {
                    lastZOrder = obj.ViewportIndex;
                }
            }
            else
            {
                obj.ViewportIndex = ++lastZOrder;
            }

            if (obj.ViewportIndex == 1)
            {
                MogitorsRoot.Instance.ActiveViewport = obj;
            }

            parent     = MogitorsRoot.Instance.RootEditor;
            obj.Parent = parent;
            obj.ProcessParameters(parameters);
            obj.Load();

            InstanceCount++;
            return(obj);
        }
예제 #3
0
        public override void DestroyObject(BaseEditor _object)
        {
            ViewportEditor editor = _object as ViewportEditor;

            MogitorsRoot.Instance.IsClearScreenNeeded = true;

            editor.DestroyAllChildren();
            editor.UnLoad();

            if (editor.Name != "")
            {
                MogitorsRoot.Instance.UnRegisterObjectName(editor.Name, editor);
            }

            InstanceCount--;

            NameObjectPairList viewports = MogitorsRoot.Instance.GetObjectsByType(EditorType.Viewport);

            lastZOrder = 0;
            foreach (ViewportEditor viewport in viewports.Values)
            {
                if (viewport.ViewportIndex > lastZOrder)
                {
                    lastZOrder = viewport.ViewportIndex;
                }
            }
        }
예제 #4
0
        private void SaveEditorStates(Ray mouseRay)
        {
            BaseEditor selected = MogitorsRoot.Instance.Selected;

            if (selected == null)
            {
                return;
            }

            PropertyInfo prop = selected.GetType().GetProperty("Scale");

            if (prop != null)
            {
                this.lastScale = (Vector3)prop.GetValue(selected, null);
            }
            else
            {
                this.lastScale = new Vector3(1, 1, 1);
            }

            this.lastDerivedOrient   = selected.DerivedOrientation;
            this.lastDerivedPosition = selected.DerivedPosition;
            this.lastUsedPlane       = MogitorsRoot.Instance.FindGizmoTranslationPlane(mouseRay, EditorAxis);
            this.last3DDelta         = MogitorsRoot.Instance.GetGizmoIntersect(mouseRay, this.lastUsedPlane, EditorAxis, this.lastDerivedPosition);
        }
예제 #5
0
        public virtual void OnMouseLeftDown(Vector2 point, MouseDevice mouseDevice)
        {
            this.lastMouse       = point;
            this.lastClickPoint  = point;
            this.lastMouseDevice = mouseDevice;

            if (mouseDevice.RightButton == MouseButtonState.Pressed)
            {
                return;
            }

            Mogre.Ray mouseRay;
            GetMouseRay(this.lastMouse, out mouseRay);

            BaseEditor selected = MogitorsRoot.Instance.Selected;

            if (selected != null && selected == GetObjectUnderMouse(mouseRay, true, true))
            {
                SaveEditorStates(mouseRay);

                isEditing = true;
            }
            else
            {
                isEditing = false;
            }
        }
        private void ClearEditors()
        {
            this.activeDragData = null;

            DestroyGizmo();

            // Make sure to unload all the viewports first, since they are dependent on SceneManager
            // but they share the same parent with scene manager and scene manager may get deleted before they do
            foreach (KeyValuePair <string, BaseEditor> it in this.namesByType[(int)EditorType.Viewport])
            {
                it.Value.UnLoad();
            }

            this.rootEditor.Destroy(false);
            this.rootEditor = null;

            ActiveViewport          = null;
            this.sceneManager       = null;
            this.sceneManagerEditor = null;
            this.selectedEditor     = null;
            this.objCounter         = 0;
            IsSceneModified         = false;
            IsSceneLoaded           = false;
            this.nameList.Clear();
            this.updateList.Clear();
            SceneUpdated = null;

            foreach (KeyValuePair <string, BaseEditorFactory> it in this.editorObjectFactories)
            {
                if (it.Value != null)
                {
                    it.Value.InstanceCount = 0;
                }
            }

            foreach (NameObjectPairList it in this.namesByType)
            {
                it.Clear();
            }

            foreach (NameObjectPairList it in this.namesByTypeID)
            {
                it.Clear();
            }

            BaseEditor parent = null;

            Mogre.NameValuePairList parameters = new Mogre.NameValuePairList();
            this.rootEditor = BaseEditor.Factory.CreateObject(ref parent, parameters);

            this.gizmoNode    = null;
            this.gizmoX       = null;
            this.gizmoY       = null;
            this.gizmoZ       = null;
            this.oldGizmoMode = EditorTools.None;
            this.oldGizmoAxis = AxisType.None;
        }
        public BaseEditor CreateEditorObject(BaseEditor parent, string objectTypeString, Mogre.NameValuePairList param, bool addToTreeList, bool display)
        {
            if (parent == null)
            {
                Mogre.NameValuePairList.Iterator ni;
                if ((ni = param.Find("ParentNode")) != param.End())
                {
                    parent = FindObject(ni.Value, 0);
                }

                if (parent == null)
                {
                    if (SceneManager == null)
                    {
                        parent = this.rootEditor;
                    }
                    else
                    {
                        parent = SceneManagerEditor;
                    }
                }
            }

            BaseEditorFactory factory = GetEditorObjectFactory(objectTypeString);

            if (factory == null)
            {
                return(null);
            }

            BaseEditor obj = factory.CreateObject(ref parent, param);

            if (obj == null)
            {
                return(null);
            }

            RegisterObjectName(obj.Name, obj);

            parent.AddChild(obj);

            if (addToTreeList)
            {
                object handle = this.system.InsertTreeItem(parent.TreeItemHandle, obj.Name, obj.ObjectTypeID, System.Windows.Media.Colors.Black);
                obj.TreeItemHandle = handle;
            }

            if (display)
            {
                obj.Load();
                obj.UpdateTreeView();
            }

            IsSceneModified = true;
            return(obj);
        }
예제 #8
0
        public virtual void DeleteSelectedObject(bool silent)
        {
            BaseEditor selected = MogitorsRoot.Instance.Selected;

            if (selected == null || !selected.Supports(EditFlags.CanDelete))
            {
                return;
            }

            bool cont = false;

            if (!silent)
            {
                string strWarn;
                if (selected.IsNodeType)
                {
                    strWarn = "Are you sure want to delete " + selected.Name + " and all of its children?";
                }
                else if (selected.EditorType == EditorType.Multisel)
                {
                    strWarn = "Are you sure want to delete all selected objects?";
                }
                else
                {
                    strWarn = "Are you sure want to delete " + selected.Name + "?";
                }

                if (MogitorsSystem.Instance.DisplayMessageDialog(strWarn, MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                    cont = true;
                }
            }
            else
            {
                cont = true;
            }

            if (!cont)
            {
                return;
            }

            BaseEditor delEd = selected;

            if (delEd.EditorType == EditorType.Multisel)
            {
                throw new System.NotImplementedException("Delete MultiSelEditor");
            }
            else
            {
                MogitorsRoot.Instance.DestroyEditorObject(delEd, true);
            }

            EditorAxis = AxisType.None;
        }
예제 #9
0
        public virtual void DestroyObject(BaseEditor _object)
        {
            _object.UnLoad();
            _object.DestroyAllChildren();
            if (_object.Name != "")
            {
                MogitorsRoot.Instance.UnRegisterObjectName(_object.Name, _object);
            }

            InstanceCount--;
        }
예제 #10
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            SceneManagerEditor editor = new SceneManagerEditor();

            editor.ProcessParameters(parameters);
            editor.Parent = parent;
            editor.Load();

            InstanceCount++;
            return(editor);
        }
예제 #11
0
 public void RegisterForPostSceneUpdates(BaseEditor obj)
 {
     if (IsSceneLoaded)
     {
         obj.PostSceneUpdate(this, new SceneUpdatedEventArgs(SceneManager, ActiveViewport.CameraEditor.Camera, RenderTarget));
     }
     else
     {
         SceneUpdated += obj.PostSceneUpdate;
     }
 }
        public void DestroyEditorObject(BaseEditor obj, bool removeFromTreeList)
        {
            // Index0 Viewport can not be deleted
            if (obj.EditorType == EditorType.Viewport)
            {
                ViewportEditor viewport = obj as ViewportEditor;

                if (viewport.ViewportIndex == 1)
                {
                    MogitorsSystem.Instance.DisplayMessageDialog("Can not delete the main viewport!!", System.Windows.MessageBoxButton.OK);
                    return;
                }

                if (ActiveViewport == viewport)
                {
                    foreach (var vt in this.namesByType[(int)EditorType.Viewport])
                    {
                        if (vt.Value == obj)
                        {
                            continue;
                        }

                        ActiveViewport = vt.Value as ViewportEditor;
                        break;
                    }
                }
            }

            if (this.selectedEditor == obj)
            {
                obj.IsSelected    = false;
                obj.IsHighLighted = false;
            }

            if (removeFromTreeList)
            {
                this.system.DeleteTreeItem(obj.TreeItemHandle);
            }

            if (obj.Parent != null)
            {
                obj.Parent.RemoveChild(obj.Name);
            }

            obj.FactoryDynamic.DestroyObject(obj);

            IsSceneModified = true;
        }
예제 #13
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            LightEditor obj = new LightEditor();

            NameValuePairList.Iterator ni;
            if ((ni = parameters.Find("Init")) != parameters.End())
            {
                parameters["Name"] = "Light" + MogitorsRoot.Instance.CreateUniqueID("Light", "", -1);
            }

            obj.ProcessParameters(parameters);
            obj.Parent = parent;

            InstanceCount++;
            return(obj);
        }
예제 #14
0
        private void DoSelect(Ray mouseRay)
        {
            BaseEditor currentSelection = MogitorsRoot.Instance.Selected;
            BaseEditor newSelection     = GetObjectUnderMouse(mouseRay, true, true);

            if (newSelection != null && newSelection != currentSelection)
            {
                newSelection.UpdateTreeView();

                EditorAxis = AxisType.None;
            }
            else if (newSelection == null && currentSelection != null)
            {
                ClearSelection();
            }
        }
        public void UnRegisterObjectName(string name, BaseEditor obj)
        {
            if (this.nameList.ContainsKey(name))
            {
                this.nameList.Remove(name);
            }

            if (this.namesByType[(int)obj.EditorType].ContainsKey(name))
            {
                this.namesByType[(int)obj.EditorType].Remove(name);
            }

            if (this.namesByTypeID[(int)obj.ObjectTypeID].ContainsKey(name))
            {
                this.namesByTypeID[(int)obj.ObjectTypeID].Remove(name);
            }
        }
예제 #16
0
        private void RecurseFillTreeView(BaseEditor editor, object parent)
        {
            foreach (EditorType editorType in this.objectDisplayOrder)
            {
                foreach (KeyValuePair <string, BaseEditor> child in editor.Children)
                {
                    if (child.Value.EditorType != editorType)
                    {
                        continue;
                    }

                    object item = this.system.InsertTreeItem(parent, child.Value.Name, child.Value.ObjectTypeID, Colors.Black);
                    child.Value.TreeItemHandle = item;
                    RecurseFillTreeView(child.Value, item);
                }
            }
        }
예제 #17
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            MaterialEditor obj = new MaterialEditor();

            Mogre.NameValuePairList.Iterator ni;
            if ((ni = parameters.Find("Init")) != parameters.End())
            {
                parameters["Name"] = "Material" + MogitorsRoot.Instance.CreateUniqueID("Material", "", 1);
            }

            obj.ProcessParameters(parameters);
            parent     = MogitorsRoot.Instance.SceneManagerEditor;
            obj.Parent = parent;

            InstanceCount++;
            return(obj);
        }
예제 #18
0
        public override void ShowBoundingBox(bool bShow)
        {
            if (this.handle == null)
            {
                return;
            }

            this.handle.ShowBoundingBox = bShow;

            foreach (KeyValuePair <string, BaseEditor> child in Children)
            {
                BaseEditor current = child.Value;
                if (current.EditorType != EditorType.Movable && current.EditorType != EditorType.Entity && current.EditorType != EditorType.Base)
                {
                    current.ShowBoundingBox(bShow);
                }
            }
        }
예제 #19
0
        private void HighlightObjectAtPosition(Ray mouseRay)
        {
            BaseEditor selected = GetObjectUnderMouse(mouseRay, false, false);

            foreach (var iter in highLighted)
            {
                if (iter.Value != selected)
                {
                    iter.Value.IsHighLighted = false;
                }
            }
            highLighted.Clear();

            if (selected != null)
            {
                selected.IsHighLighted = true;
                highLighted.Add(selected.Name, selected);
            }
        }
        public Mogre.Vector3 GetGizmoIntersectCameraPlane(BaseEditor obj, Mogre.Ray pickRay)
        {
            Mogre.Vector3            vPos   = obj.DerivedPosition;
            Mogre.Pair <bool, float> result = pickRay.Intersects(new Mogre.Plane(-ActiveViewport.CameraEditor.Camera.DerivedDirection, vPos));

            if (result.first)
            {
                Mogre.Vector3 AxisX = obj.DerivedOrientation.XAxis;
                Mogre.Vector3 AxisY = obj.DerivedOrientation.YAxis;
                Mogre.Vector3 AxisZ = obj.DerivedOrientation.ZAxis;

                Mogre.Vector3 Proj  = pickRay.GetPoint(result.second) - vPos;
                Mogre.Vector3 vPos1 = (AxisX.DotProduct(Proj) * AxisX);
                Mogre.Vector3 vPos2 = (AxisY.DotProduct(Proj) * AxisY);
                Mogre.Vector3 vPos3 = (AxisZ.DotProduct(Proj) * AxisZ);
                vPos += vPos1 + vPos2 + vPos3;
            }

            return(vPos);
        }
예제 #21
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            EntityEditor editor = new EntityEditor();

            if (parameters.Find("MeshFile") == parameters.End())
            {
                parameters["MeshFile"] = "scbCamera.mesh";
            }

            if (parameters.Find("Init") != parameters.End())
            {
                string entName = Path.GetFileNameWithoutExtension(parameters["MeshFile"]);
                parameters["Name"] = entName + MogitorsRoot.Instance.CreateUniqueID(entName, "", -1);
            }

            editor.ProcessParameters(parameters);
            editor.Parent = parent;

            InstanceCount++;
            return(editor);
        }
예제 #22
0
        private void CreateViewport()
        {
            Mogre.NameValuePairList parameters = new Mogre.NameValuePairList();

            parameters["Name"]         = "intViewCamera" + Mogre.StringConverter.ToString(ViewportIndex);
            parameters["ClipDistance"] = "0.1 40000";

            BaseEditor scnMgr = MogitorsRoot.Instance.SceneManagerEditor;

            ViewCamera = CameraEditor.Factory.CreateObject(ref scnMgr, parameters) as CameraEditor;
            ViewCamera.Load();

            this.handle = MogitorsRoot.Instance.RenderTarget.AddViewport(ViewCamera.Camera, (int)ViewportIndex,
                                                                         dimensions.x, dimensions.y, dimensions.z, dimensions.w);

            if (Name == "")
            {
                this.name = "Viewport" + Mogre.StringConverter.ToString(ViewportIndex);
            }

            ViewCamera.Camera.AspectRatio = (float)this.handle.ActualWidth / (float)this.handle.ActualHeight;
            ViewCamera.ShowHelper         = false;

            ActiveCamera = ViewCamera;
            this.handle.BackgroundColour = this.colour;

            PopCompositors();

            ProjectOptions opt = MogitorsRoot.Instance.ProjectOptions;

            if (opt.Cameras.Count > 0)
            {
                ViewCamera.Position    = opt.Cameras[opt.Cameras.Count - 1].Position;
                ViewCamera.Orientation = opt.Cameras[opt.Cameras.Count - 1].Orientation;
            }

            LoadEditorObjects();
        }
예제 #23
0
        MogitorsRoot()
        {
            this.system      = MogitorsSystem.Instance;
            this.namesByType = new NameObjectPairList[(int)EditorType.LastEditor];
            for (int i = 0; i < this.namesByType.Count(); ++i)
            {
                this.namesByType[i] = new NameObjectPairList();
            }
            this.namesByTypeID = new NameObjectPairList[MogitorSettings.Instance.MaxObjectType];
            for (int i = 0; i < this.namesByTypeID.Count(); ++i)
            {
                this.namesByTypeID[i] = new NameObjectPairList();
            }

            IsSceneLoaded   = false;
            IsSceneModified = false;

            RegisterAllEditorObjects();
            BaseEditor nullParent = null;

            this.rootEditor = BaseEditor.Factory.CreateObject(ref nullParent, null);

            this.objectDisplayOrder.Clear();
            this.objectDisplayOrder.Add(EditorType.Viewport);
            this.objectDisplayOrder.Add(EditorType.SceneManager);
            this.objectDisplayOrder.Add(EditorType.CustomNamanger);
            this.objectDisplayOrder.Add(EditorType.Light);
            this.objectDisplayOrder.Add(EditorType.Camera);
            for (EditorType type = EditorType.Camera + 1; type < EditorType.LastEditor; ++type)
            {
                this.objectDisplayOrder.Add(type);
            }
            this.objectDisplayOrder.Add(EditorType.Node);

            IsClearScreenNeeded = false;

            ProjectOptions = new ProjectOptions();
        }
예제 #24
0
        public virtual void OnMouseMove(Vector2 point, MouseDevice mouseDevice, bool imitate)
        {
            this.lastMouseDevice = mouseDevice;

            if (isSettingPos)
            {
                isSettingPos   = false;
                this.lastMouse = point;
                return;
            }

            float deltaX = (point.x - lastMouse.x) * 0.5f;
            float deltaY = (point.y - lastMouse.y) * 0.5f;

            MogitorsRoot mogRoot  = MogitorsRoot.Instance;
            BaseEditor   selected = mogRoot.Selected;

            Ray mouseRay;

            if (!imitate)
            {
                if (mouseDevice.MiddleButton == MouseButtonState.Pressed)
                {
                    Vector3 vPos   = ActiveCamera.DerivedPosition;
                    Vector3 vDelta = new Vector3(deltaX * CameraSpeed / 3.0f, -deltaY * CameraSpeed / 3.0f, 0);
                    ActiveCamera.DerivedPosition = (vPos + (ActiveCamera.DerivedOrientation * vDelta));
                    this.newCamPosition          = Vector3.ZERO;
                    MogitorsSystem.Instance.ShowMouseCursor(false);

                    point.x -= (deltaX * 2.0f);
                    point.y -= (deltaY * 2.0f);

                    isSettingPos = true;
                    MogitorsSystem.Instance.SetMousePosition(point + new Vector2(this.handle.ActualLeft, this.handle.ActualTop));
                }
                else if (mouseDevice.RightButton == MouseButtonState.Pressed)
                {
                    ActiveCamera.Yaw(new Degree(-deltaX / 4.0f));
                    ActiveCamera.Pitch(new Degree(-deltaY / 4.0f));
                    MogitorsSystem.Instance.ShowMouseCursor(false);

                    point.x -= (deltaX * 2.0f);
                    point.y -= (deltaY * 2.0f);

                    isSettingPos = true;
                    MogitorsSystem.Instance.SetMousePosition(point + new Vector2(this.handle.ActualLeft, this.handle.ActualTop));

                    if (!GetMouseRay(point, out mouseRay))
                    {
                        return;
                    }

                    if (mogRoot.Selected != null)
                    {
                        this.lastUsedPlane = MogitorsRoot.Instance.FindGizmoTranslationPlane(mouseRay, EditorAxis);
                    }
                }
            }

            if (!GetMouseRay(point, out mouseRay))
            {
                return;
            }

            if (EditorTool != EditorTools.Rotate || selected == null)
            {
                this.lastMouse = point;
            }

            if (selected != null)
            {
                if (EditorAxis == AxisType.None)
                {
                    AxisType axis = AxisType.None;
                    mogRoot.PickGizmos(mouseRay, ref axis);
                    mogRoot.HighlightGizmo(axis);
                }
                else
                {
                    mogRoot.HighlightGizmo(EditorAxis);
                }
            }

            if (isEditing && selected != null)
            {
                if ((EditorTool == EditorTools.Move) && selected.Supports(EditFlags.CanMove))
                {
                    Vector3 vNewPos = Vector3.ZERO;

                    vNewPos = mogRoot.GetGizmoIntersect(mouseRay, this.lastUsedPlane, EditorAxis, this.lastDerivedPosition);
                    vNewPos = vNewPos - this.last3DDelta + this.lastDerivedPosition;

                    selected.DerivedPosition = vNewPos;
                }
                else if ((EditorTool == EditorTools.Scale) && selected.Supports(EditFlags.CanScale))
                {
                    Vector3 vNewDist = mogRoot.GetGizmoIntersect(mouseRay, this.lastUsedPlane, EditorAxis, this.lastDerivedPosition);
                    Vector3 vScale   = this.lastScale;
                    float   fNewDist = vNewDist.Length;
                    float   fLength  = this.last3DDelta.Length;

                    if ((int)(EditorAxis & AxisType.X) != 0)
                    {
                        vScale.x *= (fNewDist / fLength);
                    }
                    if ((int)(EditorAxis & AxisType.Y) != 0)
                    {
                        vScale.y *= (fNewDist / fLength);
                    }
                    if ((int)(EditorAxis & AxisType.Z) != 0)
                    {
                        vScale.z *= (fNewDist / fLength);
                    }

                    PropertyInfo prop = selected.GetType().GetProperty("Scale");
                    if (prop != null)
                    {
                        prop.SetValue(selected, vScale, null);
                    }
                }
                else if ((EditorTool == EditorTools.Rotate) && selected.Supports(EditFlags.CanRotate))
                {
                    Quaternion q1 = this.lastDerivedOrient;

                    switch (EditorAxis)
                    {
                    case AxisType.X:
                        q1 = q1 * new Quaternion(new Degree(-deltaY), new Vector3(1, 0, 0));
                        break;

                    case AxisType.Y:
                        q1 = q1 * new Quaternion(new Degree(-deltaY), new Vector3(0, 1, 0));
                        break;

                    case AxisType.Z:
                        q1 = q1 * new Quaternion(new Degree(-deltaY), new Vector3(0, 0, 1));
                        break;
                    }

                    selected.DerivedOrientation = q1;
                }
            }

            HighlightObjectAtPosition(mouseRay);
        }
예제 #25
0
 public void UnRegisterForUpdates(BaseEditor obj)
 {
     this.updateList.Remove(obj.Name);
 }
예제 #26
0
        public override BaseEditor CreateObject(ref BaseEditor parent, NameValuePairList parameters)
        {
            ViewportEditor obj = new ViewportEditor();

            Mogre.NameValuePairList.Iterator ni;
            if ((ni = parameters.Find("ViewportIndex")) != parameters.End())
            {
                obj.ViewportIndex = (uint)Mogre.StringConverter.ParseInt(ni.Value);
                if (lastZOrder < obj.ViewportIndex)
                    lastZOrder = obj.ViewportIndex;
            }
            else
            {
                obj.ViewportIndex = ++lastZOrder;
            }

            if (obj.ViewportIndex == 1)
                MogitorsRoot.Instance.ActiveViewport = obj;

            parent = MogitorsRoot.Instance.RootEditor;
            obj.Parent = parent;
            obj.ProcessParameters(parameters);
            obj.Load();

            InstanceCount++;
            return obj;
        }
예제 #27
0
        public override void DestroyObject(BaseEditor _object)
        {
            ViewportEditor editor = _object as ViewportEditor;

            MogitorsRoot.Instance.IsClearScreenNeeded = true;

            editor.DestroyAllChildren();
            editor.UnLoad();

            if (editor.Name != "")
                MogitorsRoot.Instance.UnRegisterObjectName(editor.Name, editor);

            InstanceCount--;

            NameObjectPairList viewports = MogitorsRoot.Instance.GetObjectsByType(EditorType.Viewport);

            lastZOrder = 0;
            foreach (ViewportEditor viewport in viewports.Values)
            {
                if (viewport.ViewportIndex > lastZOrder)
                    lastZOrder = viewport.ViewportIndex;
            }
        }
예제 #28
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            EntityEditor editor = new EntityEditor();

            if (parameters.Find("MeshFile") == parameters.End())
                parameters["MeshFile"] = "scbCamera.mesh";

            if (parameters.Find("Init") != parameters.End())
            {
                string entName = Path.GetFileNameWithoutExtension(parameters["MeshFile"]);
                parameters["Name"] = entName + MogitorsRoot.Instance.CreateUniqueID(entName, "", -1);
            }

            editor.ProcessParameters(parameters);
            editor.Parent = parent;

            InstanceCount++;
            return editor;
        }
예제 #29
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            MaterialEditor obj = new MaterialEditor();

            Mogre.NameValuePairList.Iterator ni;
            if ((ni = parameters.Find("Init")) != parameters.End())
            {
                parameters["Name"] = "Material" + MogitorsRoot.Instance.CreateUniqueID("Material", "", 1);
            }

            obj.ProcessParameters(parameters);
            parent = MogitorsRoot.Instance.SceneManagerEditor;
            obj.Parent = parent;

            InstanceCount++;
            return obj;
        }
예제 #30
0
        public override SceneFileResult Import(string importFile)
        {
            MogitorsRoot   mogRoot = MogitorsRoot.Instance;
            MogitorsSystem system  = MogitorsSystem.Instance;

            if (importFile == "")
            {
                Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
                dlg.FileName   = "";
                dlg.DefaultExt = ".mogscene";
                dlg.Filter     = "Mogitor Scene File (.mogscene)|*.mogscene";
                Nullable <bool> result = dlg.ShowDialog();
                if (result != true)
                {
                    return(SceneFileResult.Cancel);
                }
                importFile = dlg.FileName;
            }

            string filePath = system.ExtractFilePath(importFile);
            string fileName = system.ExtractFileName(importFile);

            XmlTextReader textReader = new XmlTextReader(importFile);

            system.UpdateLoadProgress(5, "Loading scene objects");

            if (!textReader.ReadToFollowing("MogitorScene"))
            {
                return(SceneFileResult.ErrParse);
            }

            // Check version
            string fileVersion = textReader.GetAttribute("Version");

            if (fileVersion != null)
            {
                if (int.Parse(fileVersion) != 1)
                {
                    return(SceneFileResult.ErrParse);
                }
            }

            // Read project options
            if (textReader.ReadToFollowing("ProjectOptions") == true)
            {
                system.UpdateLoadProgress(15, "Parsing project options");
                mogRoot.LoadProjectOptions(textReader);

                mogRoot.ProjectOptions.ProjectDir  = filePath;
                mogRoot.ProjectOptions.ProjectName = fileName;

                mogRoot.PrepareProjectResources();
            }

            //// Moves the reader back to the "MogitorScene" element node.
            //textReader.MoveToElement();

            system.UpdateLoadProgress(30, "Creating scene objects");

            // Load objects
            Mogre.NameValuePairList param = new Mogre.NameValuePairList();
            while (textReader.ReadToNextSibling("Object"))
            {
                string objectType = textReader.GetAttribute("Type");
                if (objectType == "")
                {
                    continue;
                }

                param.Clear();
                while (textReader.MoveToNextAttribute())
                {
                    param.Insert(textReader.Name, textReader.Value);
                }

                BaseEditor result = MogitorsRoot.Instance.CreateEditorObject(null, objectType, param, false, false);
            }

            mogRoot.AfterLoadScene();

            return(SceneFileResult.Ok);
        }
예제 #31
0
        private void RecurseFillTreeView(BaseEditor editor, object parent)
        {
            foreach (EditorType editorType in this.objectDisplayOrder)
            {
                foreach (KeyValuePair<string, BaseEditor> child in editor.Children)
                {
                    if (child.Value.EditorType != editorType)
                        continue;

                    object item = this.system.InsertTreeItem(parent, child.Value.Name, child.Value.ObjectTypeID, Colors.Black);
                    child.Value.TreeItemHandle = item;
                    RecurseFillTreeView(child.Value, item);
                }
            }
        }
예제 #32
0
 public void RegisterForUpdates(BaseEditor obj)
 {
     this.updateList.Add(obj.Name, obj);
 }
예제 #33
0
 public virtual BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
 {
     InstanceCount++;
     return new BaseEditor();
 }
예제 #34
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            LightEditor obj = new LightEditor();

            NameValuePairList.Iterator ni;
            if ((ni = parameters.Find("Init")) != parameters.End())
            {
                parameters["Name"] = "Light" + MogitorsRoot.Instance.CreateUniqueID("Light", "", -1);
            }

            obj.ProcessParameters(parameters);
            obj.Parent = parent;

            InstanceCount++;
            return obj;
        }
예제 #35
0
 public void AddChild(BaseEditor child)
 {
     this.children.Add(child.Name, child);
     child.Parent = this;
 }
예제 #36
0
 public virtual BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
 {
     InstanceCount++;
     return(new BaseEditor());
 }
예제 #37
0
 public void AddChild(BaseEditor child)
 {
     this.children.Add(child.Name, child);
     child.Parent = this;
 }
예제 #38
0
 public void RegisterForPostSceneUpdates(BaseEditor obj)
 {
     if (IsSceneLoaded)
         obj.PostSceneUpdate(this, new SceneUpdatedEventArgs(SceneManager, ActiveViewport.CameraEditor.Camera, RenderTarget));
     else
         SceneUpdated += obj.PostSceneUpdate;
 }
예제 #39
0
        public virtual void DestroyObject(BaseEditor _object)
        {
            _object.UnLoad();
            _object.DestroyAllChildren();
            if (_object.Name != "")
                MogitorsRoot.Instance.UnRegisterObjectName(_object.Name, _object);

            InstanceCount--;
        }
 public void RegisterObjectName(string name, BaseEditor obj)
 {
     this.nameList.Add(name, obj);
     this.namesByType[(int)obj.EditorType].Add(name, obj);
     this.namesByTypeID[(int)obj.ObjectTypeID].Add(name, obj);
 }
예제 #41
0
 public void RegisterForUpdates(BaseEditor obj)
 {
     this.updateList.Add(obj.Name, obj);
 }
예제 #42
0
 public void UnRegisterForUpdates(BaseEditor obj)
 {
     this.updateList.Remove(obj.Name);
 }
예제 #43
0
        public override BaseEditor CreateObject(ref BaseEditor parent, Mogre.NameValuePairList parameters)
        {
            SceneManagerEditor editor = new SceneManagerEditor();

            editor.ProcessParameters(parameters);
            editor.Parent = parent;
            editor.Load();

            InstanceCount++;
            return editor;
        }