Пример #1
0
		protected override void LoadContent()
		{
			this.MapContent = new ContentManager(this.Services);
			this.MapContent.RootDirectory = this.Content.RootDirectory;

			GeeUIMain.Font = this.Content.Load<SpriteFont>(this.Font);

			if (this.firstLoadContentCall)
			{
				this.firstLoadContentCall = false;

				if (!Directory.Exists(this.MapDirectory))
					Directory.CreateDirectory(this.MapDirectory);
				string challengeDirectory = Path.Combine(this.MapDirectory, "Challenge");
				if (!Directory.Exists(challengeDirectory))
					Directory.CreateDirectory(challengeDirectory);

#if VR
				if (this.VR)
				{
					this.vrLeftMesh.Load(this, Ovr.Eye.Left, this.vrLeftFov);
					this.vrRightMesh.Load(this, Ovr.Eye.Right, this.vrRightFov);
					new CommandBinding(this.ReloadedContent, (Action)this.vrLeftMesh.Reload);
					new CommandBinding(this.ReloadedContent, (Action)this.vrRightMesh.Reload);
					this.reallocateVrTargets();

					this.vrCamera = new Camera();
					this.AddComponent(this.vrCamera);
				}
#endif

				this.GraphicsDevice.PresentationParameters.PresentationInterval = PresentInterval.Immediate;
				this.GeeUI = new GeeUIMain();
				this.AddComponent(GeeUI);

				this.ConsoleUI = new ConsoleUI();
				this.AddComponent(ConsoleUI);

				this.Console = new Console.Console();
				this.AddComponent(Console);

				Lemma.Console.Console.BindType(null, this);
				Lemma.Console.Console.BindType(null, Console);

				// Initialize Wwise
				AkGlobalSoundEngineInitializer initializer = new AkGlobalSoundEngineInitializer(Path.Combine(this.Content.RootDirectory, "Wwise"));
				this.AddComponent(initializer);

				this.Listener = new AkListener();
				this.Listener.Add(new Binding<Vector3>(this.Listener.Position, this.Camera.Position));
				this.Listener.Add(new Binding<Vector3>(this.Listener.Forward, this.Camera.Forward));
				this.Listener.Add(new Binding<Vector3>(this.Listener.Up, this.Camera.Up));
				this.AddComponent(this.Listener);

				// Create the renderer.
				this.LightingManager = new LightingManager();
				this.AddComponent(this.LightingManager);
				this.Renderer = new Renderer(this, true, true, true, true, true);

				this.AddComponent(this.Renderer);
				this.Renderer.ReallocateBuffers(this.ScreenSize);

				this.renderParameters = new RenderParameters
				{
					Camera = this.Camera,
					IsMainRender = true
				};

				// Load strings
				this.Strings.Load(Path.Combine(this.Content.RootDirectory, "Strings.xlsx"));

				this.UI = new UIRenderer();
				this.UI.GeeUI = this.GeeUI;
				this.AddComponent(this.UI);

				PCInput input = new PCInput();
				this.AddComponent(input);

				Lemma.Console.Console.BindType(null, input);
				Lemma.Console.Console.BindType(null, UI);
				Lemma.Console.Console.BindType(null, Renderer);
				Lemma.Console.Console.BindType(null, LightingManager);

				input.Add(new CommandBinding(input.GetChord(new PCInput.Chord { Modifier = Keys.LeftAlt, Key = Keys.S }), delegate()
				{
					// High-resolution screenshot
					bool originalModelsVisible = Editor.EditorModelsVisible;
					Editor.EditorModelsVisible.Value = false;
					Screenshot s = new Screenshot();
					this.AddComponent(s);
					s.Take(new Point(4096, 2304), delegate()
					{
						string desktop = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
						string path;
						int i = 0;
						do
						{
							path = Path.Combine(desktop, string.Format("lemma-screen{0}.png", i));
							i++;
						}
						while (File.Exists(path));

						Screenshot.SavePng(s.Buffer, path);

						Editor.EditorModelsVisible.Value = originalModelsVisible;

						s.Delete.Execute();
					});
				}));

				this.performanceMonitor = new ListContainer();
				this.performanceMonitor.Add(new Binding<Vector2, Point>(performanceMonitor.Position, x => new Vector2(x.X, 0), this.ScreenSize));
				this.performanceMonitor.AnchorPoint.Value = new Vector2(1, 0);
				this.performanceMonitor.Visible.Value = false;
				this.performanceMonitor.Name.Value = "PerformanceMonitor";
				this.UI.Root.Children.Add(this.performanceMonitor);

				Action<string, Property<double>> addTimer = delegate(string label, Property<double> property)
				{
					TextElement text = new TextElement();
					text.FontFile.Value = this.Font;
					text.Add(new Binding<string, double>(text.Text, x => label + ": " + (x * 1000.0).ToString("F") + "ms", property));
					this.performanceMonitor.Children.Add(text);
				};

				Action<string, Property<int>> addCounter = delegate(string label, Property<int> property)
				{
					TextElement text = new TextElement();
					text.FontFile.Value = this.Font;
					text.Add(new Binding<string, int>(text.Text, x => label + ": " + x.ToString(), property));
					this.performanceMonitor.Children.Add(text);
				};

				TextElement frameRateText = new TextElement();
				frameRateText.FontFile.Value = this.Font;
				frameRateText.Add(new Binding<string, float>(frameRateText.Text, x => "FPS: " + x.ToString("0"), this.frameRate));
				this.performanceMonitor.Children.Add(frameRateText);

				addTimer("Physics", this.physicsTime);
				addTimer("Update", this.updateTime);
				addTimer("Render", this.renderTime);
				addCounter("Draw calls", this.drawCalls);
				addCounter("Triangles", this.triangles);
				addCounter("Working set", this.workingSet);

				Lemma.Console.Console.AddConCommand(new ConCommand("perf", "Toggle the performance monitor", delegate(ConCommand.ArgCollection args)
				{
					this.performanceMonitor.Visible.Value = !this.performanceMonitor.Visible;
				}));

				try
				{
					IEnumerable<string> globalStaticScripts = Directory.GetFiles(Path.Combine(this.Content.RootDirectory, "GlobalStaticScripts"), "*", SearchOption.AllDirectories).Select(x => Path.Combine("..\\GlobalStaticScripts", Path.GetFileNameWithoutExtension(x)));
					foreach (string scriptName in globalStaticScripts)
						this.executeStaticScript(scriptName);
				}
				catch (IOException)
				{

				}

				this.UIFactory = new UIFactory();
				this.AddComponent(this.UIFactory);
				this.AddComponent(this.Menu); // Have to do this here so the menu's Awake can use all our loaded stuff

				this.Spawner = new Spawner();
				this.AddComponent(this.Spawner);

				this.UI.IsMouseVisible.Value = true;

				AKRESULT akresult = AkBankLoader.LoadBank("SFX_Bank_01.bnk");
				if (akresult != AKRESULT.AK_Success)
					Log.d(string.Format("Failed to load main sound bank: {0}", akresult));

#if ANALYTICS
				this.SessionRecorder = new Session.Recorder(this);

				this.SessionRecorder.Add("Position", delegate()
				{
					Entity p = PlayerFactory.Instance;
					if (p != null && p.Active)
						return p.Get<Transform>().Position;
					else
						return Vector3.Zero;
				});

				this.SessionRecorder.Add("Health", delegate()
				{
					Entity p = PlayerFactory.Instance;
					if (p != null && p.Active)
						return p.Get<Player>().Health;
					else
						return 0.0f;
				});

				this.SessionRecorder.Add("Framerate", delegate()
				{
					return this.frameRate;
				});

				this.SessionRecorder.Add("WorkingSet", delegate()
				{
					return this.workingSet;
				});
				this.AddComponent(this.SessionRecorder);
				this.SessionRecorder.Add(new Binding<bool, Config.RecordAnalytics>(this.SessionRecorder.EnableUpload, x => x == Config.RecordAnalytics.On, this.Settings.Analytics));
#endif

				this.DefaultLighting();

				new SetBinding<float>(this.Settings.SoundEffectVolume, delegate(float value)
				{
					AkSoundEngine.SetRTPCValue(AK.GAME_PARAMETERS.VOLUME_SFX, MathHelper.Clamp(value, 0.0f, 1.0f));
				});

				new SetBinding<float>(this.Settings.MusicVolume, delegate(float value)
				{
					AkSoundEngine.SetRTPCValue(AK.GAME_PARAMETERS.VOLUME_MUSIC, MathHelper.Clamp(value, 0.0f, 1.0f));
				});

				new TwoWayBinding<LightingManager.DynamicShadowSetting>(this.Settings.DynamicShadows, this.LightingManager.DynamicShadows);
				new TwoWayBinding<float>(this.Settings.MotionBlurAmount, this.Renderer.MotionBlurAmount);
				new TwoWayBinding<float>(this.Settings.Gamma, this.Renderer.Gamma);
				new TwoWayBinding<bool>(this.Settings.Bloom, this.Renderer.EnableBloom);
				new TwoWayBinding<bool>(this.Settings.SSAO, this.Renderer.EnableSSAO);
				new Binding<float>(this.Camera.FieldOfView, this.Settings.FieldOfView);

				foreach (string file in Directory.GetFiles(this.MapDirectory, "*.xlsx", SearchOption.TopDirectoryOnly))
					this.Strings.Load(file);

				new Binding<string, Config.Lang>(this.Strings.Language, x => x.ToString(), this.Settings.Language);
				new NotifyBinding(this.SaveSettings, this.Settings.Language);

				new CommandBinding(this.MapLoaded, delegate()
				{
					this.Renderer.BlurAmount.Value = 0.0f;
					this.Renderer.Tint.Value = new Vector3(1.0f);
				});

#if VR
				if (this.VR)
				{
					Action loadVrEffect = delegate()
					{
						this.vrEffect = this.Content.Load<Effect>("Effects\\Oculus");
					};
					loadVrEffect();
					new CommandBinding(this.ReloadedContent, loadVrEffect);

					this.UI.Add(new Binding<Point>(this.UI.RenderTargetSize, this.ScreenSize));

					this.VRUI = new Lemma.Components.ModelNonPostProcessed();
					this.VRUI.MapContent = false;
					this.VRUI.DrawOrder.Value = 100000; // On top of everything
					this.VRUI.Filename.Value = "Models\\plane";
					this.VRUI.EffectFile.Value = "Effects\\VirtualUI";
					this.VRUI.Add(new Binding<Microsoft.Xna.Framework.Graphics.RenderTarget2D>(this.VRUI.GetRenderTarget2DParameter("Diffuse" + Lemma.Components.Model.SamplerPostfix), this.UI.RenderTarget));
					this.VRUI.Add(new Binding<Matrix>(this.VRUI.Transform, delegate()
					{
						Matrix rot = this.Camera.RotationMatrix;
						Matrix mat = Matrix.Identity;
						mat.Forward = rot.Right;
						mat.Right = rot.Forward;
						mat.Up = rot.Up;
						mat *= Matrix.CreateScale(7);
						mat.Translation = this.Camera.Position + rot.Forward * 4.0f;
						return mat;
					}, this.Camera.Position, this.Camera.RotationMatrix));
					this.AddComponent(this.VRUI);

					this.UI.Setup3D(this.VRUI.Transform);
				}
#endif

#if ANALYTICS
				bool editorLastEnabled = this.EditorEnabled;
				new CommandBinding<string>(this.LoadingMap, delegate(string newMap)
				{
					if (this.MapFile.Value != null && !editorLastEnabled)
					{
						this.SessionRecorder.RecordEvent("ChangedMap", newMap);
						if (!this.IsChallengeMap(this.MapFile) && this.MapFile.Value != Main.MenuMap)
							this.SaveAnalytics();
					}
					this.SessionRecorder.Reset();
					editorLastEnabled = this.EditorEnabled;
				});
#endif
				new CommandBinding<string>(this.LoadingMap, delegate(string newMap)
				{
					this.CancelScheduledSave();
				});

#if !DEVELOPMENT
				IO.MapLoader.Load(this, MenuMap);
				this.Menu.Show(initial: true);
#endif

#if ANALYTICS
				if (this.Settings.Analytics.Value == Config.RecordAnalytics.Ask)
				{
					this.Menu.ShowDialog("\\analytics prompt", "\\enable analytics", delegate()
					{
						this.Settings.Analytics.Value = Config.RecordAnalytics.On;
					},
					"\\disable analytics", delegate()
					{
						this.Settings.Analytics.Value = Config.RecordAnalytics.Off;
					});
				}
#endif

#if VR
				if (this.oculusNotFound)
					this.Menu.HideMessage(null, this.Menu.ShowMessage(null, "Error: no Oculus found."), 6.0f);

				if (this.VR)
				{
					this.Menu.EnableInput(false);
					Container vrMsg = this.Menu.BuildMessage("\\vr message", 300.0f);
					vrMsg.AnchorPoint.Value = new Vector2(0.5f, 0.5f);
					vrMsg.Add(new Binding<Vector2, Point>(vrMsg.Position, x => new Vector2(x.X * 0.5f, x.Y * 0.5f), this.ScreenSize));
					this.UI.Root.Children.Add(vrMsg);
					input.Bind(this.Settings.RecenterVRPose, PCInput.InputState.Down, this.VRHmd.RecenterPose);
					input.Bind(this.Settings.RecenterVRPose, PCInput.InputState.Down, delegate()
					{
						if (vrMsg != null)
						{
							vrMsg.Delete.Execute();
							vrMsg = null;
						}
						this.Menu.EnableInput(true);
					});
				}
				else
#endif
				{
					input.Bind(this.Settings.ToggleFullscreen, PCInput.InputState.Down, delegate()
					{
						if (this.Settings.Fullscreen) // Already fullscreen. Go to windowed mode.
							this.ExitFullscreen();
						else // In windowed mode. Go to fullscreen.
							this.EnterFullscreen();
					});
				}

				input.Bind(this.Settings.QuickSave, PCInput.InputState.Down, delegate()
				{
					this.SaveWithNotification(true);
				});
			}
			else
			{
				this.ReloadingContent.Execute();
				foreach (IGraphicsComponent c in this.graphicsComponents)
					c.LoadContent(true);
				this.ReloadedContent.Execute();
			}

			this.GraphicsDevice.RasterizerState = new RasterizerState { MultiSampleAntiAlias = false };

			if (this.spriteBatch != null)
				this.spriteBatch.Dispose();
			this.spriteBatch = new SpriteBatch(this.GraphicsDevice);
		}
Пример #2
0
        public override void Awake()
        {
            this.Serialize         = false;
            this.EnabledWhenPaused = false;

            {
                Container container = this.main.UIFactory.CreateContainer();
                container.Opacity.Value       = UIFactory.Opacity;
                container.PaddingBottom.Value = container.PaddingLeft.Value = container.PaddingRight.Value = container.PaddingTop.Value = 16.0f * this.main.FontMultiplier;
                container.AnchorPoint.Value   = new Vector2(1.0f, 0.0f);
                bool vr = false;
#if VR
                vr = this.main.VR;
#endif
                container.Add(new Binding <Vector2, Point>(container.Position, x => new Vector2(x.X * 0.9f, x.Y * (vr ? 0.3f : 0.1f)), this.main.ScreenSize));
                container.Visible.Value = false;
                this.main.UI.Root.Children.Add(container);
                container.Add(new CommandBinding(this.Delete, container.Delete));
                container.Add(new CommandBinding(this.ShowEnd, container.Delete));
                container.Add(new CommandBinding(this.Show, delegate() { container.Visible.Value = true; }));

                ListContainer list = new ListContainer();
                list.Orientation.Value = ListContainer.ListOrientation.Vertical;
                list.Alignment.Value   = ListContainer.ListAlignment.Max;
                container.Children.Add(list);

                TextElement elapsedTime = new TextElement();
                elapsedTime.FontFile.Value = this.main.FontLarge;
                elapsedTime.Add(new Binding <string, float>(elapsedTime.Text, SecondsToTimeString, this.ElapsedTime));
                list.Children.Add(elapsedTime);

                TextElement vertSpeed = this.main.UIFactory.CreateLabel();
                vertSpeed.Add(new Binding <string, float>(vertSpeed.Text, x => x.ToString("00.00"), this.verticalSpeed));
                list.Children.Add(vertSpeed);

                TextElement horizontalSpeed = main.UIFactory.CreateLabel();
                horizontalSpeed.Add(new Binding <string, float>(horizontalSpeed.Text, x => x.ToString("00.00"), this.horizontalSpeed));
                list.Children.Add(horizontalSpeed);

                TextElement bestTime = this.main.UIFactory.CreateLabel();
                bestTime.Add(new Binding <string, float>(bestTime.Text, SecondsToTimeString, this.BestTime));
                list.Children.Add(bestTime);
            }

            this.ShowEnd.Action = delegate()
            {
                if (this.shown)
                {
                    return;
                }
                this.shown = true;

                Container container = this.main.UIFactory.CreateContainer();
                container.Opacity.Value       = UIFactory.Opacity;
                container.PaddingBottom.Value = container.PaddingLeft.Value = container.PaddingRight.Value = container.PaddingTop.Value = 16.0f * this.main.FontMultiplier;
                container.AnchorPoint.Value   = new Vector2(0.5f, 0.5f);
                container.Add(new Binding <Vector2, Point>(container.Position, x => new Vector2(x.X * 0.5f, x.Y * 0.5f), this.main.ScreenSize));
                this.main.UI.Root.Children.Add(container);
                container.Add(new CommandBinding(this.Delete, container.Delete));

                ListContainer list = new ListContainer();
                list.Orientation.Value = ListContainer.ListOrientation.Vertical;
                list.Alignment.Value   = ListContainer.ListAlignment.Middle;
                list.Spacing.Value     = this.spacing;
                container.Children.Add(list);

                TextElement elapsedTime = new TextElement();
                elapsedTime.FontFile.Value = this.main.FontLarge;
                elapsedTime.Add(new Binding <string, float>(elapsedTime.Text, SecondsToTimeString, this.ElapsedTime));
                list.Children.Add(elapsedTime);

                TextElement bestTime = this.main.UIFactory.CreateLabel();
                bestTime.Add(new Binding <string>(bestTime.Text, () => string.Format(main.Strings.Get("best time"), SecondsToTimeString(this.BestTime)), this.BestTime, main.Strings.Language));
                list.Children.Add(bestTime);

#if STEAMWORKS
                Container leaderboard = this.main.UIFactory.CreateContainer();
                this.resizeContainer(leaderboard);
                list.Children.Add(leaderboard);

                ListContainer leaderboardList = new ListContainer();
                leaderboardList.ResizePerpendicular.Value = false;
                leaderboardList.Size.Value        = new Vector2(this.width - 8.0f, 0);
                leaderboardList.Orientation.Value = ListContainer.ListOrientation.Vertical;
                leaderboardList.Alignment.Value   = ListContainer.ListAlignment.Middle;
                leaderboardList.Spacing.Value     = 0;

                Scroller scroller = new Scroller();
                scroller.Children.Add(leaderboardList);
                scroller.Add(new Binding <Vector2>(scroller.Size, () => new Vector2(leaderboardList.Size.Value.X, this.main.ScreenSize.Value.Y * 0.5f), leaderboardList.Size, this.main.ScreenSize));
                leaderboard.Children.Add(scroller);

                {
                    TextElement leaderboardLabel = this.main.UIFactory.CreateLabel();
                    leaderboardLabel.Text.Value = "\\leaderboard";
                    leaderboardList.Children.Add(leaderboardLabel);
                    TextElement loading = this.main.UIFactory.CreateLabel();
                    loading.Text.Value = "\\loading";
                    leaderboardList.Children.Add(loading);
                }

                this.OnLeaderboardSync.Action = delegate(LeaderboardScoresDownloaded_t globalScores, LeaderboardScoresDownloaded_t friendScores)
                {
                    leaderboardList.Children.Clear();

                    {
                        TextElement leaderboardLabel = this.main.UIFactory.CreateLabel("\\leaderboard");
                        Container   labelContainer   = this.main.UIFactory.CreateContainer();
                        leaderboardList.Children.Add(labelContainer);
                        labelContainer.Children.Add(leaderboardLabel);
                    }

                    int[] details = new int[] {};
                    for (int i = 0; i < globalScores.m_cEntryCount; i++)
                    {
                        LeaderboardEntry_t entry;
                        SteamUserStats.GetDownloadedLeaderboardEntry(globalScores.m_hSteamLeaderboardEntries, i, out entry, details, 0);
                        leaderboardList.Children.Add(this.leaderboardEntry(entry));
                    }

                    if (friendScores.m_cEntryCount > 1)
                    {
                        {
                            TextElement friendsLabel   = this.main.UIFactory.CreateLabel("\\friends");
                            Container   labelContainer = this.main.UIFactory.CreateContainer();
                            leaderboardList.Children.Add(labelContainer);
                            labelContainer.Children.Add(friendsLabel);
                        }

                        for (int i = 0; i < friendScores.m_cEntryCount; i++)
                        {
                            LeaderboardEntry_t entry;
                            SteamUserStats.GetDownloadedLeaderboardEntry(friendScores.m_hSteamLeaderboardEntries, i, out entry, details, 0);
                            leaderboardList.Children.Add(this.leaderboardEntry(entry));
                        }
                    }
                };

                this.OnLeaderboardError.Action = delegate()
                {
                    leaderboardList.Children.Clear();
                    TextElement error = this.main.UIFactory.CreateLabel();
                    error.Text.Value = "\\leaderboard error";
                    leaderboardList.Children.Add(error);
                };
#endif

                Container retry = this.main.UIFactory.CreateButton("\\retry", delegate()
                {
                    this.Retry.Execute();
                });
                this.resizeButton(retry);
                list.Children.Add(retry);

                if (this.main.Settings.GodModeProperty || Path.GetDirectoryName(this.main.MapFile) == this.main.CustomMapDirectory)
                {
                    Container edit = this.main.UIFactory.CreateButton("\\edit mode", delegate()
                    {
                        this.Edit.Execute();
                    });
                    this.resizeButton(edit);
                    list.Children.Add(edit);
                }

                if (!string.IsNullOrEmpty(this.NextMap))
                {
                    Container next = this.main.UIFactory.CreateButton("\\next level", delegate()
                    {
                        this.LoadNextMap.Execute();
                    });
                    this.resizeButton(next);
                    list.Children.Add(next);
                }

                {
                    Container challenge = this.main.UIFactory.CreateButton("\\challenge levels", delegate()
                    {
                        this.MainMenu.Execute();
                        this.main.Menu.ShowChallengeMenu();
                    });
                    this.resizeButton(challenge);
                    list.Children.Add(challenge);
                }

                Container mainMenu = this.main.UIFactory.CreateButton("\\main menu", delegate()
                {
                    this.MainMenu.Execute();
                });
                this.resizeButton(mainMenu);
                list.Children.Add(mainMenu);

                this.main.UI.IsMouseVisible.Value = true;

                const float gamepadMoveInterval = 0.1f;
                float       lastGamepadMove     = 0.0f;

                Func <int, int, int> nextButton = delegate(int search, int dir)
                {
                    int i = search;
                    while (true)
                    {
                        i = i + dir;
                        if (i < 0)
                        {
                            i = list.Children.Count - 1;
                        }
                        else if (i >= list.Children.Count)
                        {
                            i = 0;
                        }
                        UIComponent item = list.Children[i];
                        if (item is Container)
                        {
                            return(i);
                        }
                    }
                };

                int selected = nextButton(0, 1);
                if (main.GamePadConnected)
                {
                    list.Children[selected].Highlighted.Value = true;
                }

                PCInput      input         = this.Entity.GetOrCreate <PCInput>();
                Action <int> moveSelection = delegate(int delta)
                {
                    if (this.main.GameTime.TotalGameTime.TotalSeconds - lastGamepadMove > gamepadMoveInterval)
                    {
                        Container button;
                        if (selected < list.Children.Length)
                        {
                            button = (Container)list.Children[selected];
                            button.Highlighted.Value = false;
                        }

                        selected = nextButton(selected, delta);

                        button = (Container)list.Children[selected];
                        button.Highlighted.Value = true;
                        lastGamepadMove          = (float)this.main.GameTime.TotalGameTime.TotalSeconds;
                    }
                };

                input.Add(new CommandBinding(input.GetButtonDown(Buttons.LeftThumbstickUp), delegate()
                {
                    moveSelection(-1);
                }));

                input.Add(new CommandBinding(input.GetButtonDown(Buttons.DPadUp), delegate()
                {
                    moveSelection(-1);
                }));

                input.Add(new CommandBinding(input.GetButtonDown(Buttons.LeftThumbstickDown), delegate()
                {
                    moveSelection(1);
                }));

                input.Add(new CommandBinding(input.GetButtonDown(Buttons.DPadDown), delegate()
                {
                    moveSelection(1);
                }));

                input.Add(new CommandBinding(input.GetButtonDown(Buttons.A), delegate()
                {
                    if (selected < list.Children.Count)
                    {
                        UIComponent selectedItem = list.Children[selected];
                        selectedItem.MouseLeftUp.Execute();
                    }
                }));
            };
        }
Пример #3
0
 private void notifyNextInputListeners(PCInput.PCInputBinding input)
 {
     foreach (Action<PCInput.PCInputBinding> listener in this.nextInputListeners)
         listener(input);
     this.nextInputListeners.Clear();
     this.preventKeyDownEvents = true;
 }
Пример #4
0
        protected override void LoadContent()
        {
            if (this.firstLoadContentCall)
            {
                // First time loading content. Create the renderer.
                this.LightingManager = new LightingManager();
                this.AddComponent(this.LightingManager);
                this.Renderer = new Renderer(this, this.ScreenSize, true, true, false);

                this.AddComponent(this.Renderer);
                this.renderParameters = new RenderParameters
                {
                    Camera = this.Camera,
                    IsMainRender = true
                };
                this.firstLoadContentCall = false;

                this.UI = new UIRenderer();
                this.AddComponent(this.UI);

            #if PERFORMANCE_MONITOR
                ListContainer performanceMonitor = new ListContainer();
                performanceMonitor.Add(new Binding<Vector2, Point>(performanceMonitor.Position, x => new Vector2(0, x.Y), this.ScreenSize));
                performanceMonitor.AnchorPoint.Value = new Vector2(0, 1);
                performanceMonitor.Visible.Value = false;
                performanceMonitor.Name.Value = "PerformanceMonitor";
                this.UI.Root.Children.Add(performanceMonitor);

                Action<string, Property<double>> addLabel = delegate(string label, Property<double> property)
                {
                    TextElement text = new TextElement();
                    text.FontFile.Value = "Font";
                    text.Add(new Binding<string, double>(text.Text, x => label + ": " + (x * 1000.0).ToString("F") + "ms", property));
                    performanceMonitor.Children.Add(text);
                };

                TextElement frameRateText = new TextElement();
                frameRateText.FontFile.Value = "Font";
                frameRateText.Add(new Binding<string, float>(frameRateText.Text, x => "FPS: " + x.ToString("0"), this.frameRate));
                performanceMonitor.Children.Add(frameRateText);

                addLabel("Physics", this.physicsTime);
                addLabel("Update", this.updateTime);
                addLabel("Pre-frame", this.preframeTime);
                addLabel("Raw render", this.rawRenderTime);
                addLabel("Shadow render", this.shadowRenderTime);
                addLabel("Post-process", this.postProcessTime);

                PCInput input = new PCInput();
                input.Add(new CommandBinding(input.GetChord(new PCInput.Chord { Modifier = Keys.LeftAlt, Key = Keys.P }), delegate()
                {
                    performanceMonitor.Visible.Value = !performanceMonitor.Visible;
                }));
                this.AddComponent(input);
            #endif

                IEnumerable<string> globalStaticScripts = Directory.GetFiles(Path.Combine(this.Content.RootDirectory, "Maps", "GlobalStaticScripts"), "*", SearchOption.AllDirectories).Select(x => Path.Combine("Maps", "GlobalStaticScripts", Path.GetFileNameWithoutExtension(x)));
                foreach (string scriptName in globalStaticScripts)
                    this.executeStaticScript(scriptName);
            }
            else
            {
                foreach (IComponent c in this.components)
                    c.LoadContent(true);
                this.ReloadedContent.Execute();
            }
        }
Пример #5
0
		protected override void LoadContent()
		{
			if (this.firstLoadContentCall)
			{
				// Initialize Wwise
				AkGlobalSoundEngineInitializer initializer = new AkGlobalSoundEngineInitializer(Path.Combine(this.Content.RootDirectory, "Wwise"));
				this.AddComponent(initializer);

				this.Listener = new AkListener();
				this.Listener.Add(new Binding<Vector3>(this.Listener.Position, this.Camera.Position));
				this.Listener.Add(new Binding<Vector3>(this.Listener.Forward, this.Camera.Forward));
				this.Listener.Add(new Binding<Vector3>(this.Listener.Up, this.Camera.Up));
				this.AddComponent(this.Listener);

				// Create the renderer.
				this.LightingManager = new LightingManager();
				this.AddComponent(this.LightingManager);
				this.Renderer = new Renderer(this, this.ScreenSize, true, true, true, true);

				this.AddComponent(this.Renderer);
				this.renderParameters = new RenderParameters
				{
					Camera = this.Camera,
					IsMainRender = true
				};
				this.firstLoadContentCall = false;

				this.UI = new UIRenderer();
				this.AddComponent(this.UI);

				GeeUI.GeeUI.Initialize(this);

				this.ConsoleUI = new ConsoleUI();
				this.AddComponent(ConsoleUI);

				this.Console = new Console.Console();
				this.AddComponent(Console);

				PCInput input = new PCInput();
				this.AddComponent(input);

#if DEVELOPMENT
				input.Add(new CommandBinding(input.GetChord(new PCInput.Chord { Modifier = Keys.LeftAlt, Key = Keys.S }), delegate()
				{
					// High-resolution screenshot
					Screenshot s = new Screenshot();
					this.AddComponent(s);
					s.Take(new Point(4096, 2304), delegate()
					{
						string desktop = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
						string path;
						int i = 0;
						do
						{
							path = Path.Combine(desktop, "lemma-screen" + i.ToString() + ".png");
							i++;
						}
						while (File.Exists(path));

						using (Stream stream = File.OpenWrite(path))
							s.Buffer.SaveAsPng(stream, s.Size.X, s.Size.Y);
						s.Delete.Execute();
					});
				}));
#endif

#if PERFORMANCE_MONITOR
				this.performanceMonitor = new ListContainer();
				this.performanceMonitor.Add(new Binding<Vector2, Point>(performanceMonitor.Position, x => new Vector2(0, x.Y), this.ScreenSize));
				this.performanceMonitor.AnchorPoint.Value = new Vector2(0, 1);
				this.performanceMonitor.Visible.Value = false;
				this.performanceMonitor.Name.Value = "PerformanceMonitor";
				this.UI.Root.Children.Add(this.performanceMonitor);

				Action<string, Property<double>> addTimer = delegate(string label, Property<double> property)
				{
					TextElement text = new TextElement();
					text.FontFile.Value = "Font";
					text.Add(new Binding<string, double>(text.Text, x => label + ": " + (x * 1000.0).ToString("F") + "ms", property));
					this.performanceMonitor.Children.Add(text);
				};

				Action<string, Property<int>> addCounter = delegate(string label, Property<int> property)
				{
					TextElement text = new TextElement();
					text.FontFile.Value = "Font";
					text.Add(new Binding<string, int>(text.Text, x => label + ": " + x.ToString(), property));
					this.performanceMonitor.Children.Add(text);
				};

				TextElement frameRateText = new TextElement();
				frameRateText.FontFile.Value = "Font";
				frameRateText.Add(new Binding<string, float>(frameRateText.Text, x => "FPS: " + x.ToString("0"), this.frameRate));
				this.performanceMonitor.Children.Add(frameRateText);

				addTimer("Physics", this.physicsTime);
				addTimer("Update", this.updateTime);
				addTimer("Pre-frame", this.preframeTime);
				addTimer("Raw render", this.rawRenderTime);
				addTimer("Shadow render", this.shadowRenderTime);
				addTimer("Post-process", this.postProcessTime);
				addTimer("Non-post-processed", this.unPostProcessedTime);
				addCounter("Draw calls", this.drawCalls);
				addCounter("Triangles", this.triangles);

				input.Add(new CommandBinding(input.GetChord(new PCInput.Chord { Modifier = Keys.LeftAlt, Key = Keys.P }), delegate()
				{
					this.performanceMonitor.Visible.Value = !this.performanceMonitor.Visible;
				}));
#endif

				try
				{
					IEnumerable<string> globalStaticScripts = Directory.GetFiles(Path.Combine(this.Content.RootDirectory, "GlobalStaticScripts"), "*", SearchOption.AllDirectories).Select(x => Path.Combine("..\\GlobalStaticScripts", Path.GetFileNameWithoutExtension(x)));
					foreach (string scriptName in globalStaticScripts)
						this.executeStaticScript(scriptName);
				}
				catch (IOException)
				{

				}
			}
			else
			{
				foreach (IDrawableComponent c in this.drawables)
					c.LoadContent(true);
				foreach (IDrawableAlphaComponent c in this.alphaDrawables)
					c.LoadContent(true);
				foreach (IDrawablePostAlphaComponent c in this.postAlphaDrawables)
					c.LoadContent(true);
				foreach (IDrawablePreFrameComponent c in this.preframeDrawables)
					c.LoadContent(true);
				foreach (INonPostProcessedDrawableComponent c in this.nonPostProcessedDrawables)
					c.LoadContent(true);
				this.ReloadedContent.Execute();
			}

			this.GraphicsDevice.RasterizerState = new RasterizerState { MultiSampleAntiAlias = false };
		}