コード例 #1
0
    public void OnGUI()
    {
        if (Selection.activeObject is NetworkConfiguration)
        {
            NetworkConfiguration configuration = Selection.activeObject as NetworkConfiguration;

            this.configuration = configuration;
        }

        InitializeIfNull();
        InitializeStyleIfNot();

        InputHandler();

        DrawBackground();
        DrawGrid(grid_size, 0.3F, new Color(0.15F, 0.15F, 0.15F));
        DrawGrid(grid_size * 10, 0.66F, new Color(0.15F, 0.15F, 0.15F));
        DrawLinks();
        DrawNodes();
        DrawSelectRegion();

        if (editorState == EditorState.Multiselect)
        {
            Repaint();
        }

        if (GUIContextMenu.IsOpened)
        {
            GUIContextMenu.Draw();
            Repaint();
        }
    }
コード例 #2
0
    private void MouseDown()
    {
        if (configuration == null)
        {
            return;
        }

        if (inputController.isLeftMouse)
        {
            bool isPointClick = false;
            bool isNodeClick  = false;
            bool isLinkClick  = false;

            foreach (Node node in configuration.nodes)
            {
                if (ViewportService.ToScreenRect(ViewportService.GetConnectionEllipse(true, node.position, false)).Contains(inputController.mousePosition))
                {
                    isPointClick = true;

                    BeginBuild(node);

                    break;
                }
            }

            if (isPointClick == false)
            {
                foreach (Node node in configuration.nodes)
                {
                    if (ViewportService.ToScreenRect(node.position).Contains(inputController.mousePosition))
                    {
                        isNodeClick = true;

                        break;
                    }
                }
            }

            if (isNodeClick == false)
            {
                //TODO: Link selection handler here...
            }

            if (isNodeClick == false && isLinkClick == false && isPointClick == false)
            {
                ClickDownOnBackground();
            }
        }

        if (inputController.isRightMouse)
        {
            GUIContextMenu.Show(inputController.mousePosition,
                                new GUIControls.MenuItem("Create/Entry", () => CreateNode(0, GUIContextMenu.Position)),
                                new GUIControls.MenuItem("Create/Out", () => CreateNode(1, GUIContextMenu.Position)),
                                new GUIControls.MenuItem("Create/Sigmoid", () => CreateNode(2, GUIContextMenu.Position)),
                                new GUIControls.MenuItem("Create/Bias", () => CreateNode(3, GUIContextMenu.Position)));
        }

        Repaint();
    }
コード例 #3
0
        private void BuilNodeTree(MenuItem[] items)
        {
            levels = new Dictionary <int, List <MenuItem> >();

            Dictionary <string, int> keys = new Dictionary <string, int>();

            foreach (MenuItem item in items)
            {
                string[] array = item.Name.Split('/');

                for (int level = 0; level < array.Length; level++)
                {
                    string part = array[level];

                    if (!levels.ContainsKey(level))
                    {
                        levels.Add(level, new List <MenuItem>());
                    }

                    if (levels[level].Find(x => x.Name == part) == null)
                    {
                        Action action = null;

                        if (level < array.Length - 1)
                        {
                            action = () => { currentLevel++; };
                        }
                        else
                        {
                            action = () => { GUIContextMenu.Close(); item.Invoke(); };
                        }

                        levels[level].Add(new MenuItem(part, action));
                    }
                }
            }
        }
コード例 #4
0
        static void Main(string[] args)
        {
            DriverType?driverType = AskForDriver();

            if (!driverType.HasValue)
            {
                return;
            }

            device = IrrlichtDevice.CreateDevice(driverType.Value, new Dimension2Di(800, 600), 16);
            if (device == null)
            {
                return;
            }

            device.OnEvent += new IrrlichtDevice.EventHandler(device_OnEvent);
            device.SetWindowResizable(true);
            device.SetWindowCaption("Irrlicht Engine - Loading...");

            VideoDriver    driver = device.VideoDriver;
            GUIEnvironment env    = device.GUIEnvironment;
            SceneManager   smgr   = device.SceneManager;

            smgr.Attributes.SetValue(SceneParameters.COLLADA_CreateSceneInstances, true);

            driver.SetTextureCreationFlag(TextureCreationFlag.Always32Bit, true);

            smgr.AddLightSceneNode(null, new Vector3Df(200), new Colorf(1.0f, 1.0f, 1.0f), 2000);
            smgr.AmbientLight = new Colorf(0.3f, 0.3f, 0.3f);

            // add our media directory as "search path"
            device.FileSystem.AddFileArchive("../../media/");

            // read configuration from xml file
            // (we use .NET way to do this, since Lime doesn't support native Irrlicht' xml reader)
            XmlDocument xml = new XmlDocument();

            xml.Load("../../media/config.xml");
            startUpModelFile = xml.DocumentElement["startUpModel"].Attributes["file"].Value;
            caption          = xml.DocumentElement["messageText"].Attributes["caption"].Value;
            messageText      = xml.DocumentElement["messageText"].InnerText;

            if (args.Length > 0)
            {
                startUpModelFile = args[0];
            }

            // set a nicer font
            GUIFont font = env.GetFont("fonthaettenschweiler.bmp");

            if (font != null)
            {
                env.Skin.SetFont(font);
            }

            // load the irrlicht engine logo
            GUIImage img = env.AddImage(
                driver.GetTexture("irrlichtlogoalpha2.tga"),
                new Vector2Di(10, driver.ScreenSize.Height - 128));

            img.ID = (int)guiID.Logo;

            // lock the logo's edges to the bottom left corner of the screen
            img.SetAlignment(GUIAlignment.UpperLeft, GUIAlignment.UpperLeft, GUIAlignment.LowerRight, GUIAlignment.LowerRight);

            // create menu
            GUIContextMenu menu = env.AddMenu();

            menu.AddItem("File", -1, true, true);
            menu.AddItem("View", -1, true, true);
            menu.AddItem("Camera", -1, true, true);
            menu.AddItem("Help", -1, true, true);

            GUIContextMenu submenu;

            submenu = menu.GetSubMenu(0);
            submenu.AddItem("Open Model File & Texture...", (int)guiID.OpenModel);
            submenu.AddItem("Set Model Archive...", (int)guiID.SetModelArchive);
            submenu.AddItem("Load as Octree", (int)guiID.LoadAsOctree);
            submenu.AddSeparator();
            submenu.AddItem("Quit", (int)guiID.Quit);

            submenu = menu.GetSubMenu(1);
            submenu.AddItem("sky box visible", (int)guiID.SkyBoxVisible, true, false, true);
            submenu.AddItem("toggle model debug information", (int)guiID.ToggleDebugInfo, true, true);
            submenu.AddItem("model material", -1, true, true);

            submenu = submenu.GetSubMenu(1);
            submenu.AddItem("Off", (int)guiID.DebugOff);
            submenu.AddItem("Bounding Box", (int)guiID.DebugBoundingBox);
            submenu.AddItem("Normals", (int)guiID.DebugNormals);
            submenu.AddItem("Skeleton", (int)guiID.DebugSkeleton);
            submenu.AddItem("Wire overlay", (int)guiID.DebugWireOverlay);
            submenu.AddItem("Half-Transparent", (int)guiID.DebugHalfTransparent);
            submenu.AddItem("Buffers bounding boxes", (int)guiID.DebugBuffersBoundingBoxes);
            submenu.AddItem("All", (int)guiID.DebugAll);

            submenu = menu.GetSubMenu(1).GetSubMenu(2);
            submenu.AddItem("Solid", (int)guiID.ModelMaterialSolid);
            submenu.AddItem("Transparent", (int)guiID.ModelMaterialTransparent);
            submenu.AddItem("Reflection", (int)guiID.ModelMaterialReflection);

            submenu = menu.GetSubMenu(2);
            submenu.AddItem("Maya Style", (int)guiID.CameraMaya);
            submenu.AddItem("First Person", (int)guiID.CameraFirstPerson);

            submenu = menu.GetSubMenu(3);
            submenu.AddItem("About", (int)guiID.About);

            // create toolbar

            GUIToolBar bar = env.AddToolBar();

            Texture image = driver.GetTexture("open.png");

            bar.AddButton((int)guiID.ButtonOpenModel, null, "Open a model", image, null, false, true);

            image = driver.GetTexture("tools.png");
            bar.AddButton((int)guiID.ButtonShowToolbox, null, "Open Toolset", image, null, false, true);

            image = driver.GetTexture("zip.png");
            bar.AddButton((int)guiID.ButtonSelectArchive, null, "Set Model Archive", image, null, false, true);

            image = driver.GetTexture("help.png");
            bar.AddButton((int)guiID.ButtonShowAbout, null, "Open Help", image, null, false, true);

            // create a combobox with some senseless texts

            GUIComboBox box = env.AddComboBox(new Recti(250, 4, 350, 23), bar, (int)guiID.TextureFilter);

            box.AddItem("No filtering");
            box.AddItem("Bilinear");
            box.AddItem("Trilinear");
            box.AddItem("Anisotropic");
            box.AddItem("Isotropic");

            // disable alpha
            setSkinTransparency(255, env.Skin);

            // add a tabcontrol
            createToolBox();

            // create fps text
            GUIStaticText fpstext = env.AddStaticText("", new Recti(400, 4, 570, 23), true, false, bar);
            GUIStaticText postext = env.AddStaticText("", new Recti(10, 50, 470, 80), false, false, null, (int)guiID.PositionText);

            postext.Visible = false;

            // show about message box and load default model
            if (args.Length == 0)
            {
                showAboutText();
            }

            loadModel(startUpModelFile);

            // add skybox

            skybox = smgr.AddSkyBoxSceneNode(
                "irrlicht2_up.jpg", "irrlicht2_dn.jpg",
                "irrlicht2_lf.jpg", "irrlicht2_rt.jpg",
                "irrlicht2_ft.jpg", "irrlicht2_bk.jpg");

            // add a camera scene node

            camera[0]          = smgr.AddCameraSceneNodeMaya();
            camera[0].FarValue = 20000;
            // Maya cameras reposition themselves relative to their target,
            // so target the location where the mesh scene node is placed.
            camera[0].Target = new Vector3Df(0, 30, 0);

            camera[1]          = smgr.AddCameraSceneNodeFPS();
            camera[1].FarValue = 20000;
            camera[1].Position = new Vector3Df(0, 0, -70);
            camera[1].Target   = new Vector3Df(0, 30, 0);

            setActiveCamera(camera[0]);

            // set window caption
            caption = string.Format("{0} - [{1}]", caption, driver.Name);
            device.SetWindowCaption(caption);

            // remember state so we notice when the window does lose the focus
            bool hasFocus = device.WindowFocused;

            // draw everything
            while (device.Run() && driver != null)
            {
                // Catch focus changes (workaround until Irrlicht has events for this)
                bool focused = device.WindowFocused;
                if (hasFocus && !focused)
                {
                    onKillFocus();
                }

                hasFocus = focused;

                if (device.WindowActive)
                {
                    driver.BeginScene(ClearBufferFlag.All, new Color(50, 50, 50));
                    smgr.DrawAll();
                    env.DrawAll();
                    driver.EndScene();

                    string str = string.Format("FPS: {0} Tris: {1}", driver.FPS, driver.PrimitiveCountDrawn);
                    fpstext.Text = str;

                    CameraSceneNode cam = device.SceneManager.ActiveCamera;
                    str          = string.Format("Pos: {0} Tgt: {1}", cam.Position, cam.Target);
                    postext.Text = str;
                }
                else
                {
                    device.Yield();
                }
            }

            device.Drop();
        }
コード例 #5
0
        static void loadModel(string f)
        {
            string e = Path.GetExtension(f);

            switch (e)
            {
            // if a texture is loaded apply it to the current model
            case ".jpg":
            case ".pcx":
            case ".png":
            case ".ppm":
            case ".pgm":
            case ".pbm":
            case ".psd":
            case ".tga":
            case ".bmp":
            case ".wal":
            case ".rgb":
            case ".rgba":
                Texture t = device.VideoDriver.GetTexture(f);
                if (t != null && model != null)
                {
                    // always reload texture
                    device.VideoDriver.RemoveTexture(t);
                    t = device.VideoDriver.GetTexture(f);
                    model.SetMaterialTexture(0, t);
                }
                return;

            // if a archive is loaded add it to the FileArchive
            case ".pk3":
            case ".zip":
            case ".pak":
            case ".npk":
                device.FileSystem.AddFileArchive(f);
                return;
            }

            // load a model into the engine

            if (model != null)
            {
                model.Remove();
            }

            model = null;

            if (e == ".irr")
            {
                device.SceneManager.LoadScene(f);
                model = device.SceneManager.GetSceneNodeFromType(SceneNodeType.AnimatedMesh);
                return;
            }

            AnimatedMesh m = device.SceneManager.GetMesh(f);

            if (m == null)
            {
                // model could not be loaded
                if (startUpModelFile != f)
                {
                    device.GUIEnvironment.AddMessageBox(caption, "The model could not be loaded. Maybe it is not a supported file format.");
                }

                return;
            }

            // set default material properties

            if (octree)
            {
                model = device.SceneManager.AddOctreeSceneNode(m.GetMesh(0));
            }
            else
            {
                AnimatedMeshSceneNode n = device.SceneManager.AddAnimatedMeshSceneNode(m);
                model = n;
            }

            model.SetMaterialFlag(MaterialFlag.Lighting, useLight);
            model.SetMaterialFlag(MaterialFlag.NormalizeNormals, useLight);
            model.DebugDataVisible = DebugSceneType.Off;

            // we need to uncheck the menu entries. would be cool to fake a menu event, but
            // that's not so simple. so we do it brute force
            GUIContextMenu u = device.GUIEnvironment.RootElement.GetElementFromID((int)guiID.ToggleDebugInfo, true) as GUIContextMenu;

            if (u != null)
            {
                for (int i = 0; i < 6; i++)
                {
                    u.SetItemChecked(i, false);
                }
            }

            updateScaleInfo(model);
        }
コード例 #6
0
        static void OnMenuItemSelected(GUIContextMenu menu)
        {
            guiID          id  = (guiID)menu.SelectedCommandID;
            GUIEnvironment env = device.GUIEnvironment;

            switch (id)
            {
            case guiID.OpenModel:                     // FilOnButtonSetScalinge -> Open Model
                env.AddFileOpenDialog("Please select a model file to open");
                break;

            case guiID.SetModelArchive:                     // File -> Set Model Archive
                env.AddFileOpenDialog("Please select your game archive/directory");
                break;

            case guiID.LoadAsOctree:                     // File -> LoadAsOctree
                octree = !octree;
                menu.SetItemChecked(menu.SelectedIndex, octree);
                break;

            case guiID.Quit:                     // File -> Quit
                device.Close();
                break;

            case guiID.SkyBoxVisible:                     // View -> Skybox
                menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));
                skybox.Visible = !skybox.Visible;
                break;

            case guiID.DebugOff:                     // View -> Debug Information -> Off
                for (int i = 1; i <= 6; i++)
                {
                    menu.SetItemChecked(menu.SelectedIndex + i, false);
                }

                if (model != null)
                {
                    model.DebugDataVisible = DebugSceneType.Off;
                }

                break;

            case guiID.DebugBoundingBox:                     // View -> Debug Information -> Bounding Box
                menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

                if (model != null)
                {
                    model.DebugDataVisible ^= DebugSceneType.BBox;
                }

                break;

            case guiID.DebugNormals:                     // View -> Debug Information -> Normals
                menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

                if (model != null)
                {
                    model.DebugDataVisible ^= DebugSceneType.Normals;
                }

                break;

            case guiID.DebugSkeleton:                     // View -> Debug Information -> Skeleton
                menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

                if (model != null)
                {
                    model.DebugDataVisible ^= DebugSceneType.Skeleton;
                }

                break;

            case guiID.DebugWireOverlay:                     // View -> Debug Information -> Wire overlay
                menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

                if (model != null)
                {
                    model.DebugDataVisible ^= DebugSceneType.MeshWireOverlay;
                }

                break;

            case guiID.DebugHalfTransparent:                     // View -> Debug Information -> Half-Transparent
                menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

                if (model != null)
                {
                    model.DebugDataVisible ^= DebugSceneType.HalfTransparency;
                }

                break;

            case guiID.DebugBuffersBoundingBoxes:                     // View -> Debug Information -> Buffers bounding boxes
                menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

                if (model != null)
                {
                    model.DebugDataVisible ^= DebugSceneType.BBoxBuffers;
                }

                break;

            case guiID.DebugAll:                     // View -> Debug Information -> All
                for (int i = 1; i <= 6; i++)
                {
                    menu.SetItemChecked(menu.SelectedIndex - i, true);
                }

                if (model != null)
                {
                    model.DebugDataVisible = DebugSceneType.Full;
                }

                break;

            case guiID.About:                     // Help->About
                showAboutText();
                break;

            case guiID.ModelMaterialSolid:                     // View -> Material -> Solid
                if (model != null)
                {
                    model.SetMaterialType(MaterialType.Solid);
                }

                break;

            case guiID.ModelMaterialTransparent:                     // View -> Material -> Transparent
                if (model != null)
                {
                    model.SetMaterialType(MaterialType.TransparentAddColor);
                }

                break;

            case guiID.ModelMaterialReflection:                     // View -> Material -> Reflection
                if (model != null)
                {
                    model.SetMaterialType(MaterialType.SphereMap);
                }

                break;

            case guiID.CameraMaya:
                setActiveCamera(camera[0]);
                break;

            case guiID.CameraFirstPerson:
                setActiveCamera(camera[1]);
                break;
            }
        }
コード例 #7
0
ファイル: Program.cs プロジェクト: Download/Irrlicht-Lime
		static void OnMenuItemSelected(GUIContextMenu menu)
		{
			guiID id = (guiID)menu.SelectedCommandID;
			GUIEnvironment env = device.GUIEnvironment;

			switch (id)
			{
				case guiID.OpenModel: // FilOnButtonSetScalinge -> Open Model
					env.AddFileOpenDialog("Please select a model file to open");
					break;

				case guiID.SetModelArchive: // File -> Set Model Archive
					env.AddFileOpenDialog("Please select your game archive/directory");
					break;

				case guiID.LoadAsOctree: // File -> LoadAsOctree
					octree = !octree;
					menu.SetItemChecked(menu.SelectedIndex, octree);
					break;

				case guiID.Quit: // File -> Quit
					device.Close();
					break;

				case guiID.SkyBoxVisible: // View -> Skybox
					menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));
					skybox.Visible = !skybox.Visible;
					break;

				case guiID.DebugOff: // View -> Debug Information -> Off
					for (int i = 1; i <= 6; i++)
						menu.SetItemChecked(menu.SelectedIndex + i, false);

					if (model != null)
						model.DebugDataVisible = DebugSceneType.Off;

					break;

				case guiID.DebugBoundingBox: // View -> Debug Information -> Bounding Box
					menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

					if (model != null)
						model.DebugDataVisible ^= DebugSceneType.BBox;

					break;

				case guiID.DebugNormals: // View -> Debug Information -> Normals
					menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

					if (model != null)
						model.DebugDataVisible ^= DebugSceneType.Normals;

					break;

				case guiID.DebugSkeleton: // View -> Debug Information -> Skeleton
					menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

					if (model != null)
						model.DebugDataVisible ^= DebugSceneType.Skeleton;

					break;

				case guiID.DebugWireOverlay: // View -> Debug Information -> Wire overlay
					menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

					if (model != null)
						model.DebugDataVisible ^= DebugSceneType.MeshWireOverlay;

					break;

				case guiID.DebugHalfTransparent: // View -> Debug Information -> Half-Transparent
					menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

					if (model != null)
						model.DebugDataVisible ^= DebugSceneType.HalfTransparency;

					break;

				case guiID.DebugBuffersBoundingBoxes: // View -> Debug Information -> Buffers bounding boxes
					menu.SetItemChecked(menu.SelectedIndex, !menu.GetItemChecked(menu.SelectedIndex));

					if (model != null)
						model.DebugDataVisible ^= DebugSceneType.BBoxBuffers;

					break;

				case guiID.DebugAll: // View -> Debug Information -> All
					for (int i = 1; i <= 6; i++)
						menu.SetItemChecked(menu.SelectedIndex - i, true);

					if (model != null)
						model.DebugDataVisible = DebugSceneType.Full;

					break;

				case guiID.About: // Help->About
					showAboutText();
					break;

				case guiID.ModelMaterialSolid: // View -> Material -> Solid
					if (model != null)
						model.SetMaterialType(MaterialType.Solid);

					break;

				case guiID.ModelMaterialTransparent: // View -> Material -> Transparent
					if (model != null)
						model.SetMaterialType(MaterialType.TransparentAddColor);

					break;

				case guiID.ModelMaterialReflection: // View -> Material -> Reflection
					if (model != null)
						model.SetMaterialType(MaterialType.SphereMap);

					break;

				case guiID.CameraMaya:
					setActiveCamera(camera[0]);
					break;

				case guiID.CameraFirstPerson:
					setActiveCamera(camera[1]);
					break;
			}
		}