상속: IDisposable
예제 #1
0
		private void UpdateGuiParams(idUserInterface gui, idDict args)
		{
			if((gui == null) || (args == null))
			{
				return;
			}

			foreach(KeyValuePair<string, string> kvp in args.MatchPrefix("gui_parm"))
			{
				gui.State.Set(kvp.Key, kvp.Value);
			}

			gui.State.Set("noninteractive", args.GetBool("gui_noninteractive"));
			gui.StateChanged(idR.Game.Time);
		}
예제 #2
0
		private void LoadLoadingInterface(string mapName)
		{
			// load / program a gui to stay up on the screen while loading
			string mapPath = string.Format("guis/map/{0}.gui", Path.GetFileNameWithoutExtension(mapName));

			// give the gamecode a chance to override
			mapPath = idE.Game.GetMapLoadingInterface(mapPath);

			if(idE.UIManager.Exists(mapPath) == true)
			{
				_guiLoading = idE.UIManager.FindInterface(mapPath, true, false, true);
			}
			else
			{
				_guiLoading = idE.UIManager.FindInterface("guis/map/loading.gui", true, false, true);
			}

			_guiLoading.State.Set("map_loading", 0.0f);
	}
예제 #3
0
		public idWindow(idUserInterface gui)
		{
			_gui = gui;

			Init();
		}
예제 #4
0
		public void Draw(idUserInterface hud)
		{
			idRenderView renderView = _player.RenderView;

			if(idR.CvarSystem.GetBool("g_skipViewEffects") == true)
			{
				SingleView(hud, renderView);
			}
			else
			{
				// TODO:
				/*if(player->GetInfluenceMaterial() || player->GetInfluenceEntity())
				{
					InfluenceVision(hud, view);
				}
				else if(gameLocal.time < dvFinishTime)
				{
					DoubleVision(hud, view, dvFinishTime - gameLocal.time);
				}
				else if(player->PowerUpActive(BERSERK))
				{
					BerserkVision(hud, view);
				}
				else*/
				{
					SingleView(hud, renderView);
				}

				// TODO: ScreenFade();
			}

			/* TODO: lagometer
			if(net_clientLagOMeter.GetBool() && lagoMaterial && gameLocal.isClient)
			{
				renderSystem->SetColor4(1.0f, 1.0f, 1.0f, 1.0f);
				renderSystem->DrawStretchPic(10.0f, 380.0f, 64.0f, 64.0f, 0.0f, 0.0f, 1.0f, 1.0f, lagoMaterial);
			}*/
		}
예제 #5
0
		/// <summary>
		/// This is called after parsing an EntityDef and for each entity spawnArgs before
		/// merging the entitydef.  It could be done post-merge, but that would
		/// avoid the fast pre-cache check associated with each entityDef.
		/// </summary>
		/// <param name="dict"></param>
		public override void CacheDictionaryMedia(idDict dict)
		{	
			#region Model
			foreach(KeyValuePair<string, string> kvp in dict.MatchPrefix("model"))
			{
				// precache model/animations
				if((kvp.Value != string.Empty) && (idR.DeclManager.FindType<idDecl>(DeclType.ModelDef, kvp.Value, false) == null))
				{
					// precache the render model
					idR.RenderModelManager.FindModel(kvp.Value);

					// precache .cm files only
					idR.CollisionModelManager.LoadModel(kvp.Value, true);
				}
			}
			#endregion

			#region Gui
			foreach(KeyValuePair<string, string> kvp in dict.MatchPrefix("gui"))
			{
				string keyLower = kvp.Key.ToLower();

				if((keyLower == "gui_noninteractive")
					|| (keyLower.StartsWith("gui_parm") == true)
					|| (keyLower == "gui_inventory"))
				{
					// unfortunate flag names, they aren't actually a gui
				}
				else
				{
					idR.DeclManager.MediaPrint(string.Format("Precaching gui {0}", kvp.Value));

					idUserInterface gui = new idUserInterface();
					
					if(gui != null)
					{
						gui.InitFromFile(kvp.Value);
						idE.UIManager.Remove(gui);
					}					
				}
			}
			#endregion

			#region Fx
			foreach(KeyValuePair<string, string> kvp in dict.MatchPrefix("fx"))
			{
				idR.DeclManager.MediaPrint(string.Format("Precaching fx {0}", kvp.Value));
				idR.DeclManager.FindType<idDecl>(DeclType.Fx, kvp.Value);
			}
			#endregion

			#region Smoke
			foreach(KeyValuePair<string, string> kvp in dict.MatchPrefix("smoke"))
			{
				string prtName = kvp.Value;
				int dash = prtName.IndexOf('-');

				if(dash > 0)
				{
					prtName = prtName.Substring(0, dash);
				}

				idR.DeclManager.FindType(DeclType.Particle, prtName);
			}
			#endregion

			#region Skin
			foreach(KeyValuePair<string, string> kvp in dict.MatchPrefix("skin"))
			{
				idR.DeclManager.MediaPrint(string.Format("Precaching skin {0}", kvp.Value));
				idR.DeclManager.FindType(DeclType.Skin, kvp.Value);
			}
			#endregion

			#region Def
			foreach(KeyValuePair<string, string> kvp in dict.MatchPrefix("def"))
			{
				FindEntityDef(kvp.Value, false);
			}
			#endregion

			#region Misc
			string value = dict.GetString("s_shader");

			if(value != string.Empty)
			{
				idR.DeclManager.FindType<idDecl>(DeclType.Sound, value);
			}

			value = dict.GetString("texture");

			if(value != string.Empty)
			{
				idR.DeclManager.FindType<idDecl>(DeclType.Material, value);
			}

			Dictionary<string, DeclType> cacheElements = new Dictionary<string, DeclType>() {
				{ "snd", DeclType.Sound },
				{ "mtr", DeclType.Material },
				{ "inv_icon", DeclType.Material },
				{ "pda_name", DeclType.Pda },
				{ "video", DeclType.Video },
				{ "audio", DeclType.Audio }
			};

			foreach(KeyValuePair<string, DeclType> element in cacheElements)
			{
				foreach(KeyValuePair<string, string> kvp in dict.MatchPrefix(element.Key))
				{
					idR.DeclManager.FindType<idDecl>(element.Value, kvp.Value);
				}
			}
			#endregion
		}
예제 #6
0
		public idListWindow(idDeviceContext context, idUserInterface gui)
			: base(gui, context)
		{
			Init();
		}
예제 #7
0
		private void DispatchCommand(idUserInterface gui, string menuCommand, bool doIngame)
		{
			if(gui == null)
			{
				gui = _guiActive;
			}

			if(gui == _guiMainMenu)
			{
				idConsole.Warning("TODO: HandleMainMenuCommands( menuCommand );");
			}
			else if(gui == _guiIntro) 
			{
				idConsole.Warning("TODO: HandleIntroMenuCommands( menuCommand );");
			}
			else if(gui == _guiMsg) 
			{
				idConsole.Warning("TODO: HandleMsgCommands( menuCommand );");
			} 
			else if(gui == _guiTakeNotes) 
			{
				idConsole.Warning("TODO: HandleNoteCommands( menuCommand );");
			} 
			else if(gui == _guiRestartMenu) 
			{
				idConsole.Warning("TODO: HandleRestartMenuCommands( menuCommand );");
			} 
			else if((idE.Game != null) && (_guiActive != null) && (_guiActive.State.GetBool("gameDraw") == true))
			{
				string cmd = idE.Game.HandleGuiCommands(menuCommand);

				if(cmd == null)
				{
					_guiActive = null;
				}
				else if(cmd.Equals("main", StringComparison.OrdinalIgnoreCase) == true)
				{
					StartMenu();
				}
				else if(cmd.Contains("sound ") == true)
				{
					// pipe the GUI sound commands not handled by the game to the main menu code
					idConsole.Warning("TODO: HandleMainMenuCommands( cmd );");
				}
			} 
			else if(_guiHandle != null) 
			{
				idConsole.Warning("TODO: if ( (*guiHandle)( menuCommand ) ) {");

				/*if ( (*guiHandle)( menuCommand ) ) {
					return;
				}*/
			}

			else if(doIngame == false)
			{
				idConsole.DeveloperWriteLine("idSessionLocal.DispatchCommand: no dispatch found for command '{0}'", menuCommand);
			}
			else
			{
				idConsole.Warning("TODO: HandleInGameCommands( menuCommand );");
			}
		}
예제 #8
0
		public void SetUserInterface(idUserInterface ui, /* TODO: HandleGuiCommand_t*/ object handle)
		{
			_guiActive = ui;
			_guiHandle = handle;

			if(_guiMsgRestore != null)
			{
				idConsole.DeveloperWriteLine("idSession::SetUserInterface: cleared an active message box");
				_guiMsgRestore = null;
			}

			if(_guiActive == null)
			{
				return;
			}

			if(_guiActive == _guiMainMenu)
			{
				idConsole.Warning("TODO: SetSaveGameGuiVars();");
				SetMainMenuVariables();
			}
			else if(_guiActive == _guiRestartMenu)
			{
				idConsole.Warning("TODO: SetSaveGameGuiVars();");
			}

			_guiActive.HandleEvent(new SystemEvent(SystemEventType.None), idE.System.FrameTime);
			_guiActive.Activate(true, idE.System.FrameTime);
		}
		public void Remove(idUserInterface ui)
		{
			if(_guiList.Contains(ui) == true)
			{
				_guiList.Remove(ui);
			}

			if(ui.Disposed == false)
			{
				ui.Dispose();
			}
		}
		public idUserInterface FindInterface(string path, bool autoLoad = false, bool needUnique = false, bool forceNotUnique = false)
		{
			foreach(idUserInterface gui in _guiList)
			{
				if(gui.SourceFile.Equals(path, StringComparison.OrdinalIgnoreCase) == true)
				{
					if((forceNotUnique == false) && ((needUnique == true) || (gui.IsInteractive == true)))
					{
						break;
					}

					gui.AddReference();

					return gui;
				}
			}

			if(autoLoad == true)
			{
				idUserInterface gui = new idUserInterface();

				if(gui.InitFromFile(path) == true)
				{
					gui.IsUnique = (forceNotUnique == true) ? false : needUnique;
					return gui;
				}
			}

			return null;
		}
예제 #11
0
		public idSliderWindow(idUserInterface gui)
			: base(gui)
		{
			Init();
		}
예제 #12
0
 public idChoiceWindow(idUserInterface gui)
     : base(gui)
 {
     Init();
 }
예제 #13
0
		public idWindow(idUserInterface gui, idDeviceContext context)
		{
			_context = context;
			_gui = gui;

			Init();
		}
예제 #14
0
		/// <summary>
		/// Called in an orderly fashion at system startup, so commands, cvars, files, etc are all available.
		/// </summary>
		public void Init()
		{
			idConsole.WriteLine("-------- Initializing Session --------");

			// TODO: commands
			/*cmdSystem->AddCommand( "writePrecache", Sess_WritePrecache_f, CMD_FL_SYSTEM|CMD_FL_CHEAT, "writes precache commands" );

	#ifndef	ID_DEDICATED*/

			idE.CmdSystem.AddCommand("map", "loads a map", CommandFlags.System, Cmd_Map /* TODO: idCmdSystem::ArgCompletion_MapName*/);

		/*cmdSystem->AddCommand( "devmap", Session_DevMap_f, CMD_FL_SYSTEM, "loads a map in developer mode", idCmdSystem::ArgCompletion_MapName );
		cmdSystem->AddCommand( "testmap", Session_TestMap_f, CMD_FL_SYSTEM, "tests a map", idCmdSystem::ArgCompletion_MapName );

		cmdSystem->AddCommand( "writeCmdDemo", Session_WriteCmdDemo_f, CMD_FL_SYSTEM, "writes a command demo" );
		cmdSystem->AddCommand( "playCmdDemo", Session_PlayCmdDemo_f, CMD_FL_SYSTEM, "plays back a command demo" );
		cmdSystem->AddCommand( "timeCmdDemo", Session_TimeCmdDemo_f, CMD_FL_SYSTEM, "times a command demo" );
		cmdSystem->AddCommand( "exitCmdDemo", Session_ExitCmdDemo_f, CMD_FL_SYSTEM, "exits a command demo" );
		cmdSystem->AddCommand( "aviCmdDemo", Session_AVICmdDemo_f, CMD_FL_SYSTEM, "writes AVIs for a command demo" );
		cmdSystem->AddCommand( "aviGame", Session_AVIGame_f, CMD_FL_SYSTEM, "writes AVIs for the current game" );

		cmdSystem->AddCommand( "recordDemo", Session_RecordDemo_f, CMD_FL_SYSTEM, "records a demo" );
		cmdSystem->AddCommand( "stopRecording", Session_StopRecordingDemo_f, CMD_FL_SYSTEM, "stops demo recording" );
		cmdSystem->AddCommand( "playDemo", Session_PlayDemo_f, CMD_FL_SYSTEM, "plays back a demo", idCmdSystem::ArgCompletion_DemoName );
		cmdSystem->AddCommand( "timeDemo", Session_TimeDemo_f, CMD_FL_SYSTEM, "times a demo", idCmdSystem::ArgCompletion_DemoName );
		cmdSystem->AddCommand( "timeDemoQuit", Session_TimeDemoQuit_f, CMD_FL_SYSTEM, "times a demo and quits", idCmdSystem::ArgCompletion_DemoName );
		cmdSystem->AddCommand( "aviDemo", Session_AVIDemo_f, CMD_FL_SYSTEM, "writes AVIs for a demo", idCmdSystem::ArgCompletion_DemoName );
		cmdSystem->AddCommand( "compressDemo", Session_CompressDemo_f, CMD_FL_SYSTEM, "compresses a demo file", idCmdSystem::ArgCompletion_DemoName );
	#endif

		cmdSystem->AddCommand( "disconnect", Session_Disconnect_f, CMD_FL_SYSTEM, "disconnects from a game" );

		cmdSystem->AddCommand( "demoShot", Session_DemoShot_f, CMD_FL_SYSTEM, "writes a screenshot for a demo" );
		cmdSystem->AddCommand( "testGUI", Session_TestGUI_f, CMD_FL_SYSTEM, "tests a gui" );

	#ifndef	ID_DEDICATED
		cmdSystem->AddCommand( "saveGame", SaveGame_f, CMD_FL_SYSTEM|CMD_FL_CHEAT, "saves a game" );
		cmdSystem->AddCommand( "loadGame", LoadGame_f, CMD_FL_SYSTEM|CMD_FL_CHEAT, "loads a game", idCmdSystem::ArgCompletion_SaveGame );
	#endif

		cmdSystem->AddCommand( "takeViewNotes", TakeViewNotes_f, CMD_FL_SYSTEM, "take notes about the current map from the current view" );
		cmdSystem->AddCommand( "takeViewNotes2", TakeViewNotes2_f, CMD_FL_SYSTEM, "extended take view notes" );

		cmdSystem->AddCommand( "rescanSI", Session_RescanSI_f, CMD_FL_SYSTEM, "internal - rescan serverinfo cvars and tell game" );

		cmdSystem->AddCommand( "promptKey", Session_PromptKey_f, CMD_FL_SYSTEM, "prompt and sets the CD Key" );

		cmdSystem->AddCommand( "hitch", Session_Hitch_f, CMD_FL_SYSTEM|CMD_FL_CHEAT, "hitches the game" );*/

			// the same idRenderWorld will be used for all games
			// and demos, insuring that level specific models
			// will be freed
			_renderWorld = idE.RenderSystem.CreateRenderWorld();

			idConsole.Warning("TODO: init sound");
			/*sw = soundSystem->AllocSoundWorld( rw );

			menuSoundWorld = soundSystem->AllocSoundWorld( rw );*/

			// we have a single instance of the main menu
			_guiMainMenu = idE.UIManager.FindInterface("guis/mainmenu.gui", true, false, true);

			idConsole.Warning("TODO: map list");
			/*guiMainMenu_MapList = uiManager->AllocListGUI();
			guiMainMenu_MapList->Config(guiMainMenu, "mapList");
			idAsyncNetwork::client.serverList.GUIConfig(guiMainMenu, "serverList");*/

			_guiRestartMenu = idE.UIManager.FindInterface("guis/restart.gui", true, false, true);
			_guiGameOver = idE.UIManager.FindInterface("guis/gameover.gui", true, false, true);
			_guiMsg = idE.UIManager.FindInterface("guis/msg.gui", true, false, true);
			_guiTakeNotes = idE.UIManager.FindInterface("guis/takeNotes.gui", true, false, true);
			_guiIntro = idE.UIManager.FindInterface("guis/intro.gui", true, false, true);

			_whiteMaterial = idE.DeclManager.FindMaterial("_white");

			idConsole.WriteLine("session initialized");
			idConsole.WriteLine("--------------------------------------");
		}
		internal idUserInterface FindInternalInterface(idUserInterface gui)
		{
			return _guiList.Find(u => u == gui);
		}
예제 #16
0
		public bool ProcessEvent(SystemEvent ev)
		{
			// hitting escape anywhere brings up the menu
			if((_guiActive == null) && (ev.Type == SystemEventType.Key) && (ev.Value2 == 1) && (ev.Value == (int) Keys.Escape))
			{
				idConsole.Warning("TODO: escape");
			
				/*console->Close();
				if ( game ) {
					idUserInterface	*gui = NULL;
					escReply_t		op;
					op = game->HandleESC( &gui );
					if ( op == ESC_IGNORE ) {
						return true;
					} else if ( op == ESC_GUI ) {
						SetGUI( gui, NULL );
						return true;
					}
				}
				StartMenu();
				return true;*/
			}

			// let the pull-down console take it if desired
			if(idE.Console.ProcessEvent(ev, false) == true)
			{
				return true;
			}

			// if we are testing a GUI, send all events to it
			if(_guiTest != null)
			{
				// hitting escape exits the testgui
				if((ev.Type == SystemEventType.Key) && (ev.Value2 == 1) && (ev.Value == (int) Keys.Escape))
				{
					_guiTest = null;
					return true;
				}
		
				string cmd = _guiTest.HandleEvent(ev, idE.System.FrameTime);

				if(cmd != string.Empty)
				{
					idConsole.WriteLine("testGui event returned: '{0}'", cmd);
				}

				return true;
			}

			// menus / etc
			if(_guiActive != null)
			{
				ProcessMenuEvent(ev);
				return true;
			}

			// if we aren't in a game, force the console to take it
			if(_mapSpawned == false)
			{
				idE.Console.ProcessEvent(ev, true);
				return true;
			}

			// in game, exec bindings for all key downs
			if((ev.Type == SystemEventType.Key) && (ev.Value2 == 1))
			{
				idConsole.Warning("TODO: idKeyInput::ExecKeyBinding( event->evValue );");
				return true;
			}

			return false;
		}
		internal void AddInternalInterface(idUserInterface gui)
		{
			_guiList.Add(gui);
		}
예제 #18
0
		private void DispatchCommand(idUserInterface gui, string menuCommand)
		{
			DispatchCommand(gui, menuCommand, true);
		}
예제 #19
0
		public idSimpleWindow(idWindow win)
		{
			_gui = win.UserInterface;
			_context = win.DeviceContext;

			_drawRect = win.DrawRectangle;
			_clientRect = win.ClientRectangle;
			_textRect = win.TextRectangle;

			_origin = win.Origin;
			_fontFamily = win.FontFamily;
			_name = win.Name;

			_materialScaleX = win.MaterialScaleX;
			_materialScaleY = win.MaterialScaleY;

			_borderSize = win.BorderSize;
			_textAlign = win.TextAlign;
			_textAlignX = win.TextAlignX;
			_textAlignY = win.TextAlignY;
			_background = win.Background;
			_flags = win.Flags;
			_textShadow = win.TextShadow;

			_visible.Set(win.IsVisible);
			_text.Set(win.Text);
			_rect.Set(win.Rectangle);
			_backColor.Set(win.BackColor);
			_materialColor.Set(win.MaterialColor);
			_foreColor.Set(win.ForeColor);
			_borderColor.Set(win.BorderColor);
			_textScale.Set(win.TextScale);
			_rotate.Set(win.Rotate);
			_shear.Set(win.Shear);
			_backgroundName.Set(win.BackgroundName);

			if(_backgroundName != string.Empty)
			{
				_background = idE.DeclManager.FindMaterial(_backgroundName);
				_background.Sort = (float) MaterialSort.Gui; ;
				_background.ImageClassification = 1; // just for resource tracking
			}

			_backgroundName.Material = _background;

			_parent = win.Parent;
			_hideCursor.Set(win.HideCursor);

			if(_parent != null)
			{
				if(_text.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_text);
				}

				if(_visible.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_visible);
				}

				if(_rect.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_rect);
				}

				if(_backColor.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_backColor);
				}

				if(_materialColor.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_materialColor);
				}

				if(_foreColor.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_foreColor);
				}

				if(_borderColor.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_borderColor);
				}

				if(_textScale.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_textScale);
				}

				if(_rotate.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_rotate);
				}

				if(_shear.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_shear);
				}

				if(_backgroundName.NeedsUpdate == true)
				{
					_parent.AddUpdateVariable(_backgroundName);
				}
			}
		}
예제 #20
0
		public idListWindow(idUserInterface gui)
			: base(gui)
		{
			Init();
		}
예제 #21
0
		private void Clear()
		{
			_description = "<none>";
			_renderBump = string.Empty;

			_contentFlags = ContentFlags.Solid;
			_surfaceFlags = SurfaceFlags.None;
			_materialFlags = 0;

			_sort = (float) MaterialSort.Bad;
			_coverage = MaterialCoverage.Bad;
			_cullType = CullType.Front;

			_deformType = DeformType.None;
			_deformRegisters = new int[4];

			_ops = null;
			_expressionRegisters = null;
			_constantRegisters = null;
			_stages = new MaterialStage[] { };

			_stageCount = 0;
			_ambientStageCount = 0;
			_registerCount = 0;
			
			_lightFalloffImage = null;
			_entityGui = 0;
			_shouldCreateBackSides = false;
			_editorImageName = null;

			_fogLight = false;
			_blendLight = false;
			_ambientLight = false;
			_noFog = false;
			_hasSubview = false;
			_allowOverlays = true;
			_unsmoothedTangents = false;

			_userInterface = null;
			_referenceCount = 0;
			
			/*editorAlpha = 1.0;*/
			_spectrum = 0;

			_polygonOffset = 0;
			_suppressInSubview = false;
			_portalSky = false;

			_decalInfo.StayTime = 10000;
			_decalInfo.FadeTime = 4000;
			_decalInfo.Start = new float[] { 1, 1, 1, 1 };
			_decalInfo.End = new float[] { 0, 0, 0, 0 };
		}
예제 #22
0
		public /*override*/ void HandleMainMenuCommands(string menuCommand, idUserInterface gui)
		{
			idConsole.DeveloperWriteLine("HandleMainMenuCommands");
		}
예제 #23
0
		/// <summary>
		/// Parses the material, if there are any errors during parsing the defaultShader will be set.
		/// </summary>
		/// <param name="lexer"></param>
		private void ParseMaterial(idLexer lexer)
		{
			_registerCount = PredefinedRegisterCount; // leave space for the parms to be copied in.

			for(int i = 0; i < _registerCount; i++)
			{
				_parsingData.RegisterIsTemporary[i] = true; // they aren't constants that can be folded.
			}

			TextureRepeat textureRepeatDefault = TextureRepeat.Repeat; // allow a global setting for repeat.
			idToken token = null;

			string tokenValue;
			string tokenLower;
			int count;

			while(true)
			{
				if(TestMaterialFlag(Renderer.MaterialFlags.Defaulted) == true)
				{
					// we have a parse error.
					return;
				}

				if((token = lexer.ExpectAnyToken()) == null)
				{
					this.MaterialFlag = MaterialFlags.Defaulted;
					return;
				}

				tokenValue = token.ToString();
				tokenLower = tokenValue.ToLower();

				// end of material definition
				if(tokenLower == "}")
				{
					break;
				}
				else if(tokenLower == "qer_editorimage")
				{
					token = lexer.ReadTokenOnLine();
					_editorImageName = (token != null) ? token.ToString() : string.Empty;

					lexer.SkipRestOfLine();
				}
				else if(tokenLower == "description")
				{
					token = lexer.ReadTokenOnLine();
					_description = (token != null) ? token.ToString() : string.Empty;
				}
				// check for the surface / content bit flags.
				else if(CheckSurfaceParameter(token) == true)
				{

				}
				else if(tokenLower == "polygonoffset")
				{
					this.MaterialFlag = Renderer.MaterialFlags.PolygonOffset;

					if((token = lexer.ReadTokenOnLine()) == null)
					{
						_polygonOffset = 1;
					}
					else
					{
						_polygonOffset = token.ToFloat();
					}
				}
				// noshadow.
				else if(tokenLower == "noshadows")
				{
					this.MaterialFlag = MaterialFlags.NoShadows;
				}
				else if(tokenLower == "suppressinsubview")
				{
					_suppressInSubview = true;
				}
				else if(tokenLower == "portalsky")
				{
					_portalSky = true;
				}
				else if(tokenLower == "noselfshadow")
				{
					this.MaterialFlag = Renderer.MaterialFlags.NoSelfShadow;
				}
				else if(tokenLower == "noportalfog")
				{
					this.MaterialFlag = Renderer.MaterialFlags.NoPortalFog;
				}
				// forceShadows allows nodraw surfaces to cast shadows.
				else if(tokenLower == "forceshadows")
				{
					this.MaterialFlag = Renderer.MaterialFlags.ForceShadows;
				}
				// overlay / decal suppression.
				else if(tokenLower == "nooverlays")
				{
					_allowOverlays = false;
				}
				// moster blood overlay forcing for alpha tested or translucent surfaces.
				else if(tokenLower == "forceoverlays")
				{
					_parsingData.ForceOverlays = true;
				}
				else if(tokenLower == "translucent")
				{
					_coverage = MaterialCoverage.Translucent;
				}
				// global zero clamp.
				else if(tokenLower == "zeroclamp")
				{
					textureRepeatDefault = TextureRepeat.ClampToZero;
				}
				// global clamp.
				else if(tokenLower == "clamp")
				{
					textureRepeatDefault = TextureRepeat.Clamp;
				}
				// global clamp.
				else if(tokenLower == "alphazeroclamp")
				{
					textureRepeatDefault = TextureRepeat.ClampToZero;
				}
				// forceOpaque is used for skies-behind-windows.
				else if(tokenLower == "forceopaque")
				{
					_coverage = MaterialCoverage.Opaque;
				}
				else if(tokenLower == "twosided")
				{
					_cullType = CullType.TwoSided;

					// twoSided implies no-shadows, because the shadow
					// volume would be coplanar with the surface, giving depth fighting
					// we could make this no-self-shadows, but it may be more important
					// to receive shadows from no-self-shadow monsters.
					this.MaterialFlag = Renderer.MaterialFlags.NoShadows;
				}
				else if(tokenLower == "backsided")
				{
					_cullType = CullType.Back;

					// the shadow code doesn't handle this, so just disable shadows.
					// We could fix this in the future if there was a need.
					this.MaterialFlag = Renderer.MaterialFlags.NoShadows;
				}
				else if(tokenLower == "foglight")
				{
					_fogLight = true;
				}
				else if(tokenLower == "blendlight")
				{
					_blendLight = true;
				}
				else if(tokenLower == "ambientlight")
				{
					_ambientLight = true;
				}
				else if(tokenLower == "mirror")
				{
					_sort = (float) MaterialSort.Subview;
					_coverage = MaterialCoverage.Opaque;
				}
				else if(tokenLower == "nofog")
				{
					_noFog = true;
				}
				else if(tokenLower == "unsmoothedtangents")
				{
					_unsmoothedTangents = true;
				}
				// lightFallofImage <imageprogram>
				// specifies the image to use for the third axis of projected
				// light volumes.
				else if(tokenLower == "lightfalloffimage")
				{
					_lightFalloffImage = idE.ImageManager.ImageFromFile(ParsePastImageProgram(lexer), TextureFilter.Default, false, TextureRepeat.Clamp, TextureDepth.Default);
				}
				// guisurf <guifile> | guisurf entity
				// an entity guisurf must have an idUserInterface
				// specified in the renderEntity.
				else if(tokenLower == "guisurf")
				{
					token = lexer.ReadTokenOnLine();
					tokenLower = token.ToString().ToLower();

					if(tokenLower == "entity")
					{
						_entityGui = 1;
					}
					else if(tokenLower == "entity2")
					{
						_entityGui = 2;
					}
					else if(tokenLower == "entity3")
					{
						_entityGui = 3;
					}
					else
					{
						_userInterface = idE.UIManager.FindInterface(token.ToString(), true);
					}
				}
				// sort.
				else if(tokenLower == "sort")
				{
					ParseSort(lexer);
				}
				// spectrum <integer>.
				else if(tokenLower == "spectrum")
				{
					int.TryParse(lexer.ReadTokenOnLine().ToString(), out _spectrum);
				}
				// deform < sprite | tube | flare >.
				else if(tokenLower == "deform")
				{
					ParseDeform(lexer);
				}
				// decalInfo <staySeconds> <fadeSeconds> (<start rgb>) (<end rgb>).
				else if(tokenLower == "decalinfo")
				{
					ParseDecalInfo(lexer);
				}
				// renderbump <args...>.
				else if(tokenLower == "renderbump")
				{
					_renderBump = lexer.ParseRestOfLine();
				}
				// diffusemap for stage shortcut.
				else if(tokenLower == "diffusemap")
				{
					idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames);
					newLexer.LoadMemory(string.Format("blend diffusemap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "diffusemap");

					ParseStage(newLexer, textureRepeatDefault);
				}
				// specularmap for stage shortcut.
				else if(tokenLower == "specularmap")
				{
					idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames);
					newLexer.LoadMemory(string.Format("blend specularmap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "specularmap");

					ParseStage(newLexer, textureRepeatDefault);
				}
				// normalmap for stage shortcut.
				else if(tokenLower == "bumpmap")
				{
					idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames);
					newLexer.LoadMemory(string.Format("blend bumpmap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "bumpmap");

					ParseStage(newLexer, textureRepeatDefault);
				}
				// DECAL_MACRO for backwards compatibility with the preprocessor macros.
				else if(tokenLower == "decal_macro")
				{
					// polygonOffset
					this.MaterialFlag = Renderer.MaterialFlags.PolygonOffset;
					_polygonOffset = -1;

					// discrete
					_surfaceFlags |= SurfaceFlags.Discrete;
					_contentFlags &= ~ContentFlags.Solid;

					// sort decal.
					_sort = (float) MaterialSort.Decal;

					// noShadows
					this.MaterialFlag = Renderer.MaterialFlags.NoShadows;
				}
				else if(tokenValue == "{")
				{
					// create the new stage.
					ParseStage(lexer, textureRepeatDefault);
				}
				else
				{
					idConsole.WriteLine("unknown general material parameter '{0}' in '{1}'", tokenValue, this.Name);
					return;
				}
			}

			// add _flat or _white stages if needed.
			AddImplicitStages();

			// order the diffuse / bump / specular stages properly.
			SortInteractionStages();

			// if we need to do anything with normals (lighting or environment mapping)
			// and two sided lighting was asked for, flag
			// shouldCreateBackSides() and change culling back to single sided,
			// so we get proper tangent vectors on both sides.

			// we can't just call ReceivesLighting(), because the stages are still
			// in temporary form.
			if(_cullType == CullType.TwoSided)
			{
				count = _parsingData.Stages.Count;

				for(int i = 0; i < count; i++)
				{
					if((_parsingData.Stages[i].Lighting != StageLighting.Ambient) || (_parsingData.Stages[i].Texture.TextureCoordinates != TextureCoordinateGeneration.Explicit))
					{
						if(_cullType == CullType.TwoSided)
						{
							_cullType = CullType.Front;
							_shouldCreateBackSides = true;
						}

						break;
					}
				}
			}

			// currently a surface can only have one unique texgen for all the stages on old hardware.
			TextureCoordinateGeneration firstGen = TextureCoordinateGeneration.Explicit;

			count = _parsingData.Stages.Count;

			for(int i = 0; i < count; i++)
			{
				if(_parsingData.Stages[i].Texture.TextureCoordinates != TextureCoordinateGeneration.Explicit)
				{
					if(firstGen == TextureCoordinateGeneration.Explicit)
					{
						firstGen = _parsingData.Stages[i].Texture.TextureCoordinates;
					}
					else if(firstGen != _parsingData.Stages[i].Texture.TextureCoordinates)
					{
						idConsole.Warning("material '{0}' has multiple stages with a texgen", this.Name);
						break;
					}
				}
			}
		}
예제 #24
0
		public override void Spawn()
		{
			base.Spawn();

			if(this.Index >= idR.MaxClients)
			{
				idConsole.Error("entityIndex > MAX_CLIENTS for player.  Player may only be spawned with a client.");
			}

			// allow thinking during cinematics
			this.Cinematic = true;

			if(idR.Game.IsMultiplayer == true)
			{
				// always start in spectating state waiting to be spawned in
				// do this before SetClipModel to get the right bounding box
				this.IsSpectating = true;
			}

			// set our collision model
			_physicsObject.Self = this;

			SetClipModel();

			_physicsObject.SetMass(this.SpawnArgs.GetFloat("mass", 100));
			_physicsObject.SetContents(ContentFlags.Body);
			_physicsObject.SetClipMask(ContentFlags.MaskPlayerSolid);

			SetPhysics(_physicsObject);

			idConsole.Warning("TODO: InitAASLocation();");

			_skin = this.RenderEntity.CustomSkin;

			// only the local player needs guis
			if((idR.Game.IsMultiplayer == false) || (this.Index == idR.Game.LocalClientIndex))
			{
				// load HUD
				if(idR.Game.IsMultiplayer == true)
				{
					_hud = idR.UIManager.FindInterface("guis/mphud.gui", true, false, true);
				}
				else
				{
					string temp = this.SpawnArgs.GetString("hud", "");

					if(temp != string.Empty)
					{
						_hud = idR.UIManager.FindInterface(temp, true, false, true);
					}
				}

				if(_hud != null)
				{
					_hud.Activate(true, idR.Game.Time);
				}

				// load cursor
				string cursor = this.SpawnArgs.GetString("cursor", "");

				if(cursor != string.Empty)
				{
					_cursor = idR.UIManager.FindInterface(cursor, true, idR.Game.IsMultiplayer, idR.Game.IsMultiplayer);
				}

				if(_cursor != null)
				{
					_cursor.Activate(true, idR.Game.Time);
				}

				// TODO
				// objectiveSystem = uiManager->FindGui( "guis/pda.gui", true, false, true );
				// objectiveSystemOpen = false;
			}

			/*SetLastHitTime( 0 );

			// load the armor sound feedback
			declManager->FindSound( "player_sounds_hitArmor" );

			// set up conditions for animation
			LinkScriptVariables();

			animator.RemoveOriginOffset( true );*/

			// initialize user info related settings
			// on server, we wait for the userinfo broadcast, as this controls when the player is initially spawned in game
			if((idR.Game.IsClient == true) || (this.Index == idR.Game.LocalClientIndex))
			{
				UserInfoChanged(false);
			}

			// create combat collision hull for exact collision detection
			/*SetCombatModel();*/

			// supress model in non-player views, but allow it in mirrors and remote views
			this.RenderEntity.SuppressSurfaceInViewID = this.Index + 1;

			// don't project shadow on self or weapon
			this.RenderEntity.NoSelfShadow = true;

			/*idAFAttachment *headEnt = head.GetEntity();
			if ( headEnt ) {
				headEnt->GetRenderEntity()->suppressSurfaceInViewID = entityNumber+1;
				headEnt->GetRenderEntity()->noSelfShadow = true;
			}*/

			if(idR.Game.IsMultiplayer == true)
			{
				Init();
				Hide();	// properly hidden if starting as a spectator

				if(idR.Game.IsClient == false)
				{
					// set yourself ready to spawn. idMultiplayerGame will decide when/if appropriate and call SpawnFromSpawnSpot
					// TODO
					/*SetupWeaponEntity();*/
					SpawnFromSpawnSpot();

					_forceRespawn = true;
				}
			}
			else
			{
				idConsole.Warning("TODO: SetupWeaponEntity();");
				SpawnFromSpawnSpot();
			}
			
			// trigger playtesting item gives, if we didn't get here from a previous level
			// the devmap key will be set on the first devmap, but cleared on any level
			// transitions
			if((idR.Game.IsMultiplayer == false) && (idR.Game.ServerInfo.ContainsKey("devmap") == true))
			{
				idConsole.Warning("TODO: devmap");

				// fire a trigger with the name "devmap"
				/*idEntity *ent = gameLocal.FindEntity( "devmap" );
				if ( ent ) {
					ent->ActivateTargets( this );
				}*/
			}

			if(_hud != null)
			{
				idConsole.Warning("TODO: soul cube");

				// we can spawn with a full soul cube, so we need to make sure the hud knows this
				/*if ( weapon_soulcube > 0 && ( inventory.weapons & ( 1 << weapon_soulcube ) ) ) {
					int max_souls = inventory.MaxAmmoForAmmoClass( this, "ammo_souls" );
					if ( inventory.ammo[ idWeapon::GetAmmoNumForName( "ammo_souls" ) ] >= max_souls ) {
						hud->HandleNamedEvent( "soulCubeReady" );
					}
				}*/

				_hud.HandleNamedEvent("itemPickup");
			}

			idConsole.Warning("TODO: GetPDA");
			/*if ( GetPDA() ) {
				// Add any emails from the inventory
				for ( int i = 0; i < inventory.emails.Num(); i++ ) {
					GetPDA()->AddEmail( inventory.emails[i] );
				}
				GetPDA()->SetSecurity( common->GetLanguageDict()->GetString( "#str_00066" ) );
			}*/

			if(idR.Game.World.SpawnArgs.GetBool("no_Weapons") == true)
			{
				idConsole.Warning("TODO: no_Weapons");
			
				/*hiddenWeapon = true;
				if ( weapon.GetEntity() ) {
					weapon.GetEntity()->LowerWeapon();
				}
				idealWeapon = 0;*/
			} 
			else 
			{
				idConsole.Warning("TODO: hiddenWeapon = false;");
			}

			if(_hud != null)
			{
				idConsole.Warning("TODO: UpdateHudWeapon();");
				_hud.StateChanged(idR.Game.Time);
			}
			
			idConsole.Warning("TODO: inventory");

			/*tipUp = false;
			objectiveUp = false;

			if ( inventory.levelTriggers.Num() ) {
				PostEventMS( &EV_Player_LevelTrigger, 0 );
			}

			inventory.pdaOpened = false;
			inventory.selPDA = 0;*/

			if(idR.Game.IsMultiplayer == false)
			{
				int skill = idR.CvarSystem.GetInteger("g_skill");

				if(skill < 2)
				{
					if(this.Health < 25)
					{
						this.Health = 25;
					}

					if(idR.CvarSystem.GetBool("g_useDynamicProtection") == true)
					{
						idR.CvarSystem.SetFloat("g_damageScale", 1.0f);
					}
				} 
				else 
				{
					idR.CvarSystem.SetFloat("g_damageScale", 1.0f);
					idR.CvarSystem.SetFloat("g_armorProtection", (skill < 2) ? 0.4f : 0.2f);

					if(skill == 3)
					{
						idConsole.Warning("TODO: this.HealthTake = true");
						idConsole.Warning("TODO: nextHealthTake = gameLocal.time + g_healthTakeTime.GetInteger() * 1000;");
					}
				}
			}
		}
예제 #25
0
		public idChoiceWindow(idUserInterface gui)
			: base(gui)
		{
			Init();
		}
예제 #26
0
		private void SingleView(idUserInterface hud, idRenderView renderView)
		{
			// normal rendering
			if(renderView == null)
			{
				return;
			}

			// place the sound origin for the player
			// TODO: gameSoundWorld->PlaceListener( view->vieworg, view->viewaxis, player->entityNumber + 1, gameLocal.time, hud ? hud->State().GetString( "location" ) : "Undefined" );

			// if the objective system is up, don't do normal drawing
			// TODO: objectives
			/*if ( player->objectiveSystemOpen ) {
				player->objectiveSystem->Redraw( gameLocal.time );
				return;
			}
			*/

			// hack the shake in at the very last moment, so it can't cause any consistency problems
			idRenderView hackedView = renderView.Copy();
			// TODO: hackedView.viewaxis = hackedView.viewaxis * ShakeAxis();

			idR.Game.CurrentRenderWorld.RenderScene(hackedView);

			if(_player.IsSpectating == true)
			{
				return;
			}

			// draw screen blobs
			if((idR.CvarSystem.GetBool("pm_thirdPerson") == false) && (idR.CvarSystem.GetBool("g_skipViewEffects") == false))
			{
				idConsole.Warning("TODO: screen blobs");

				/*for ( int i = 0 ; i < MAX_SCREEN_BLOBS ; i++ ) {
					screenBlob_t	*blob = &screenBlobs[i];
					if ( blob->finishTime <= gameLocal.time ) {
						continue;
					}
			
					blob->y += blob->driftAmount;

					float	fade = (float)( blob->finishTime - gameLocal.time ) / ( blob->finishTime - blob->startFadeTime );
					if ( fade > 1.0f ) {
						fade = 1.0f;
					}
					if ( fade ) {
						renderSystem->SetColor4( 1,1,1,fade );
						renderSystem->DrawStretchPic( blob->x, blob->y, blob->w, blob->h,blob->s1, blob->t1, blob->s2, blob->t2, blob->material );
					}
				}
				player->DrawHUD( hud );

				// armor impulse feedback
				float	armorPulse = ( gameLocal.time - player->lastArmorPulse ) / 250.0f;

				if ( armorPulse > 0.0f && armorPulse < 1.0f ) {
					renderSystem->SetColor4( 1, 1, 1, 1.0 - armorPulse );
					renderSystem->DrawStretchPic( 0, 0, 640, 480, 0, 0, 1, 1, armorMaterial );
				}


				// tunnel vision
				float	health = 0.0f;
				if ( g_testHealthVision.GetFloat() != 0.0f ) {
					health = g_testHealthVision.GetFloat();
				} else {
					health = player->health;
				}
				float alpha = health / 100.0f;
				if ( alpha < 0.0f ) {
					alpha = 0.0f;
				}
				if ( alpha > 1.0f ) {
					alpha = 1.0f;
				}

				if ( alpha < 1.0f  ) {
					renderSystem->SetColor4( ( player->health <= 0.0f ) ? MS2SEC( gameLocal.time ) : lastDamageTime, 1.0f, 1.0f, ( player->health <= 0.0f ) ? 0.0f : alpha );
					renderSystem->DrawStretchPic( 0.0f, 0.0f, 640.0f, 480.0f, 0.0f, 0.0f, 1.0f, 1.0f, tunnelMaterial );
				}

				if ( player->PowerUpActive(BERSERK) ) {
					int berserkTime = player->inventory.powerupEndTime[ BERSERK ] - gameLocal.time;
					if ( berserkTime > 0 ) {
						// start fading if within 10 seconds of going away
						alpha = (berserkTime < 10000) ? (float)berserkTime / 10000 : 1.0f;
						renderSystem->SetColor4( 1.0f, 1.0f, 1.0f, alpha );
						renderSystem->DrawStretchPic( 0.0f, 0.0f, 640.0f, 480.0f, 0.0f, 0.0f, 1.0f, 1.0f, berserkMaterial );
					}
				}

				if ( bfgVision ) {
					renderSystem->SetColor4( 1.0f, 1.0f, 1.0f, 1.0f );
					renderSystem->DrawStretchPic( 0.0f, 0.0f, 640.0f, 480.0f, 0.0f, 0.0f, 1.0f, 1.0f, bfgMaterial );
				}*/
		
			}

			// test a single material drawn over everything
			if(idR.CvarSystem.GetString("g_testPostProcess") != string.Empty)
			{
				idMaterial material = idR.DeclManager.FindMaterial(idR.CvarSystem.GetString("g_testPostProcess"), false);

				if(material == null)
				{
					idConsole.Warning("Material not found.");
					idR.CvarSystem.SetString("g_testPostProcess", string.Empty);
				}
				else
				{
					idR.RenderSystem.Color = new Vector4(1, 1, 1, 1);
					idR.RenderSystem.DrawStretchPicture(0, 0, idE.VirtualScreenWidth, idE.VirtualScreenHeight, 0, 0, 1, 1, material);
				}
			}
		}
예제 #27
0
		private void Dispose(bool disposing)
		{
			if(this.Disposed == true)
			{
				throw new ObjectDisposedException(this.GetType().Name);
			}

			if(disposing == true)
			{
				CleanUp();

				_gui = null;
				_context = null;
				_parent = null;
				_background = null;
				_focusedChild = null;
				_captureChild = null;
				_overChild = null;				
				_children = null;
				_drawWindows = null;
				_definedVariables = null;
				_updateVariables = null;
				_scripts = null;
				_timeLineEvents = null;
				_transitions = null;
				_namedEvents = null;
				_expressionRegisters = null;
				_ops = null;
				_regList = null;
				_lastEval = null;
				_builtInVariables = null;
			}

			_disposed = true;
		}