nyuuzyou/wikis huggingface dataset:
GIMP

() is a free and open source image editor. Download it from gimp.org, or from the Microsoft Store for systems.
== Usage with Source ==
=== VTF support ===
Download the GIMP VTF plug-in here. It allows you to specify a layer as the alpha channel of the output, bypassing the issue below.
=== RGB of transparent pixels ===
GIMP's developers consider the alpha channel to represent transparency, and are not interested in supporting other uses of it. This means that GIMP is quite happy to destroy or ignore RGB color data in pixels with 0% alpha, creating horrendous problems in most 3D engines:
* When the alpha channel is not being used for transparency, visible image data is replaced by jagged-edged areas of pure black
* When alpha is transparency, semi-black borders appear around the edges of materials with sharp edges (a result of realtime GPU filtering)
Fortunately, so long as Layer masks are used the only operation known to trigger the problem in current versions of GIMP (future releases may be different!) is "Merge Layers". As a workaround, consider using "New from Visible" instead.
== Usage with GoldSrc ==
=== Export settings ===
Gimp tga export.png‎‎| export settings for TGA files(RLE compression should be disabled for 32-bit images and game icons)
Gimp bmp export.png‎‎| export settings for BMP files
== See also ==
* Gimp VTF Plugin 1.2.1 Download @ TheRaZZeRApp
* Decals in GIMP
* Normal Map Creation in The GIMP
Category:Third Party Tools
Category:Material System
Category:GIMP
Category: Third Party Source 2 Tools
GLaDOS

The deceitful computer, GLaDOS (which stands for Genetic Lifeform and Disk Operating System), is the speaker and controller behind the Aperture Science Enrichment Center.
== Origin ==
GLaDOS was created in response to the news that Black Mesa was developing a portal technology similar to that of Aperture Science. Her original purpose was to be an artificially intelligent research assistant (and disk operating system). Work on GLaDOS started in 1986, and was under development for more than ten years before she was finally completed several years after 1996. GLaDOS was activated for the first time, untested, during one of the events on Aperture Science's first annual "bring-your-daughter-to-work" day.
GLaDOS is made up of several "personality cores" in the form of strange spheres that apparently control the AI's behavior. Chell encounters a morality core, curiosity core, cake core, and anger core (in that order) while destroying GLaDOS.
== Updated Origin ==
Cave Johnson, founder of Aperture Science Center, in his wild pursuit of better portal technology, managed to contract moon rock poisoning from the powdered dust of moon rocks. Over the years, he became more and more irrational until one day, in a fit of "genius", he decided to put his assistant Caroline in his new computer core. This was in the late 1970's. The final "version" of GLaDOS was not completed until 1996. The ten years it took to actually develop GLaDOS were mostly the OS portion.
The stresses of running the Enrichment Center were apparently too much for Caroline to handle. Her mind was simply not able to deal with the amount of testing the Enrichment Center needed to have completed on a daily basis. This may have been the reason for the addition of the OS to the computer core. It is unclear what drove the combined Human/AI mind to the point it is at when we first meet GLaDOS, but one thing is clear: the compulsion to test constantly certainly was a contributing factor. It is unfortunate that Caroline was the sane, stable part of GLaDOS. Caroline was also the only thing keeping Johnson from going completely insane.
Category:Portal Continuity
Category:Portal
Category:Portal 2
GPU

== Graphics Processing Unit (GPU) ==
A Graphics Processing Unit (GPU) is a specialized electronic circuit that accelerates the rendering of images and videos for display on a computer screen. GPUs are essential components in modern gaming, visualization, and computational tasks, contributing significantly to the overall performance of a system.
=== Overview ===
The GPU is designed to handle parallel processing tasks, making it well-suited for graphics rendering, image processing, and complex mathematical computations. In gaming, the GPU plays a crucial role in generating realistic visuals by rendering three-dimensional environments and objects.
=== GPU Architecture ===
GPUs are built with specific architectures that include processing cores, memory, and a dedicated pipeline for graphics rendering. Popular GPU architectures include NVIDIA's CUDA cores, AMD's Stream Processors, and Intel's Xe Architecture.
=== Application Programming Interfaces (APIs) ===
To interact with GPUs, developers use Application Programming Interfaces (APIs) such as DirectX and OpenGL. These APIs provide a standardized way for software to communicate with the GPU, enabling the creation of graphics-intensive applications.
* For more information on DirectX, refer to Wikipedia.
* Learn about OpenGL on the VDC.
=== GPU in Source Engine Development ===
In Source engine development, understanding GPU capabilities is crucial for optimizing game performance. The engine utilizes the GPU for rendering graphics, handling shaders, and executing various visual effects.
* Explore GPU optimization techniques on the VDC.
=== Notable GPU Manufacturers ===
There are several notable GPU manufacturers in the market, each offering a range of GPUs with varying performance levels. Some of the prominent manufacturers include:
* NVIDIA: Known for their GeForce and Quadro series.
* AMD: Offers Radeon GPUs for gaming and professional use.
* Intel: Expanding into discrete GPUs with the Intel Xe series.
=== Future Trends ===
As technology advances, GPUs continue to evolve, with a focus on improved performance, energy efficiency, and support for emerging technologies such as ray tracing and artificial intelligence.
== Conclusion ==
In conclusion, GPUs are integral components in modern computing, especially in the context of gaming and graphics-intensive applications. Source engine developers benefit from a solid understanding of GPU architectures and optimization techniques to create visually stunning and high-performance games.
*For further reading, visit the Wikipedia page on GPUs.*
GUIStudioMDL

is a GUI written by Neil Jedrzejewski for the command-line-based model compiler included with the SDK.
It removes the need to use the command-line when compiling models but gives you access to all the options of the original compiler (some you may not have known!) through a simple interface.
== External links ==
* GUIStudioMDL - the download page.
Category:Third Party Tools
Category:Modeling
Gabe Newell's PC

== August 2009 ==
GabeN's specs were revealed in an email thread.
* CPU: Core i7 (overclocked) (unspecified model)
* GPU: ATI Radeon HD 4800
* Monitor: 42" Panasonic Elite 1080p monitor
* Mouse: Razer mouse (unspecified model)
* Keyboard: "ancient" MS ergonomic keyboard
=== Relevant FAQ ===
#What do you think of the Apple Cinema HD Display?I've been using Apple Cinema Displays for several years now with both nVIDIA and ATI display adapters, starting with the original 22" Cinema Display. I was tempted for a while by the Samsung 24" display, but it wasn't a big enough step forward and had problems running at its native resolution with DVI inputs. The 30" version is great, and I would recommend it as a significant improvement over the 22" or 23" versions. It works fine for games or movies. I run 2560 by 1600 for my desktop and for games that support that resolution (e.g. Source games, WoW, ...). I made a half-hearted attempt to get two Apple Cinema HD Displays working simultaneously, but the connectors interfered with each other. Most of the machines at Valve have Dell 24" LCD monitors, and a number of people have those set up in dual monitor configurations.
#Do you get playable framerates at 2560 by 1600?I get 150 to 170 FPS out of the Counter-Strike: Source VST depending upon what set of tweaks I'm running that day. That's with vsynch disabled, 16X aniso, and 6X AA.
Everybody Else's PCs
Gabe Newell's FAQ
== February 2016 Update ==
Falcon Northwest Tiki (via reddit.com/PCMasterRace)
* CPU: Intel i7-5930K
* GPU: Nvidia Titan (unspecified model)
* Monitor: Acer X34 @ 100Hz
== March 2019 Update ==
Falcon Northwest Tiki (via https://www.youtube.com/watch?v=1oY5LfXr_xk)
* CPU: Intel i7-5930K
* GPU: Nvidia GeForce GTX 1080
* RAM: 32 GB
* Storage: Intel SSD (unspecified model)
Category:Valve employees
GameUI

:Not to be confused with the game_ui entity.
GameUI is the code which provides the VGUI 'frontend': broadly speaking, the main menu and loading screens.
GameUI panels are children of their own dedicated panel ("GameUI Panel"). The client's RootPanel is used only for in-game HUD elements.
== to ==
In the original branches of Source (from to ), GameUI is a closed engine library manipulable to a limited extent by editing .res script files. These define properties like width, height, element location, and so on. You can add new non-interactive elements and with a bit of effort hide existing ones.
It is possible to create new VGUI panels that behave in exactly the same way as GameUI ones. Starting with Source 2013 (which uses elements from Team Fortress 2), such panels can override the default main menu with four new functions included in IGameUI.
It's worth noting that this version of GameUI still exists internally in every Source game made by Valve, though to what extent it is accessible or functional varies by game. Newer games (starting with ) typically only use it for the console and server browser. since newer updates have removed nearly all commands (except ) to show the original GameUI.
== to engine branch ==
The Alien Swarm SDK contains the complete source for the newer L4D-style GameUI, which has been moved into the client library. It has been redesigned for consoles' lack of a pointing device: everything is integrated into the same navigable menu system, and you can't be in more than area at once. It's also far, far easier to program.
=== Creating a new window ===
# Create a new class, inheriting from CBaseModFrame.
# Create an accompanying "<class name>.res" script in game\resource\ui\basemodui\.
# Add a new entry to the WINDOW_TYPE enum.
# Edit the enormous switch in CBaseModPanel::OpenWindow() to include your new enum and class.
The ugly enum/switch indirection is presumably designed to allow a single "window type" value to open slightly different window objects depending on the UI's state. Too bad Valve haven't found any excuse to do that yet!
=== Opening windows ===
Use CBaseModFrame* CBaseModPanel::OpenWindow():
#include "gameui\swarm\basemodpanel.h"
using namespace BaseModUI;
void openwindow()
{
	CBaseModFrame* mainMenu = CBaseModPanel::GetSingleton().GetWindow( WT_MAINMENU );
	CBaseModPanel::GetSingleton().OpenWindow( WT_GAMESETTINGS, mainMenu );
}
The arguments are:
; WINDOW_TYPE &wt
: An enum value that defines which precise window to open.
; CBaseModFrame* caller
: The window which requested this one to open. Among other things, this becomes the target of 'back' buttons on the new window.
; bool hidePrevious
: Hides caller if true.
; KeyValues* pParameters
: Passed on to the new window.
OnOpen() is called on the opened window.
=== Startup ===
The initialization sequence is:
# CGameUI::Initialize()
# CBaseModPanel::RunFrame()
# CBaseModPanel::OnGameUIActivated()
# CBaseModPanel::OpenFrontScreen()
# CBaseModPanel::OpenWindow()
CBaseModPanel is a singleton; CBaseModFrame is the base class of all windows.
== ==
Category:VGUI Category:Programming
Game Window Cursor Clipping

== Summary ==
This implementation allows you to clip the cursor to the game window such as in DOOM and DOOM Eternal (id Tech 6 - 7), also brings some fixes to various bugs on VGUI.
Those games are only meant to be examples and might not do it in the way we'll do below.
Gwccs01.gif|Example of cursor clipping
Gwccs02.gif|Example of cursor clipping while moving a VGUI panel
== Requirements ==
* Knowledge of C++
* Knowledge of Source Engine
* Source SDK Base 2013 - Currently tested on Source SDK Base 2013 Multiplayer
== Getting the Implementation/Code==
First of all, you'll need the following files from the following GitHub repository:
* source-engine-examples-cursor-clipping
Which you will copy to src/game/client/. You can also create a subfolder if you wish to, and copy these files there.
== Implementation ==
Now head over to cdll_client_int.cpp and include
#include "CCursorClipManagement.h"
Anywhere before
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
In the same cpp, find CHLClient::PostInit() and add this to the end:
CCursorClipManagement::Init();
Now find void OnRenderEnd() in the same cpp and add this to the end:
g_pCursorClipManager->Think();
Once you're done with the steps above, head over to baseviewport.cpp and add the following:
#include "../CCursorClipManagement.h"
After
// our definition
#include "baseviewport.h"
#include <filesystem.h>
#include <convar.h>
#include "ienginevgui.h"
#include "iclientmode.h"
Before
#include "tier0/etwprof.h"
Lastly, find CBaseViewport::OnScreenSizeChanged(int iOldWide, int iOldTall) and add this to the end:
g_pCursorClipManager->SetLockAction(CURSOR_CLIPMANAGEMENT_RELOCKREQUIRED);
== Conclusion ==
You're all set! Compile your client project and check if it works.
== Notes ==
* If you start the game with -tools, -dev, -developer, or -nocursorclipping, the cursor clipping will be disabled and won't work by default.
* If you're compiling into a different platform, else than WIN32, the cursor clipping will be disabled and won't work by default.
* You can also add a ConVar to enable or disable this dynamically in-game, all you'll need to do is adding one more check on CCursorClipManagement::Think().
* If you do not want to check whether the window is active or not every time OnRenderEnd() gets called, you can also do this by hooking into window events/messages. Check SetWindowsHookExA.
Category:Programming
Category:Free source code
Category:English
Game initialization

The 'ignition circuit' of every Source game and mod is the file traditonally named <game>_client.cpp. It contains several scopeless functions (i.e. not in a class) that are called when server.dll is loaded, when the world spawns, when a player connects, and so on. One of its main purposes is to create a player entity for all connecting clients. For obvious reasons there can only be one game_client.cpp in a project!
== Custom <game>_client.cpp ==
Rather than modify hl2_client.cpp or hl2mp_client.cpp it is advised to create your own. The functions defined in this file are global functions so to create your own <game>_client.cpp simply copy the existing one and rename it and then exclude the old one for the build. (right click->properties->Exclude from build -- yes),
== Client.cpp functions ==
Various console commands etc. that are processed on the server but only affect one player. Changing player model, saying things, god mode...
The code is shared between all games and mods, so don't put anything game-specific in here!
== Game_client.cpp functions ==
The functions in _client.cpp are apparently called from within the engine, and as such must always be the same.
; void ClientPutInServer()
; void ClientActive()
: Called when a player connects and activates respectively. These functions define the C++ class used for players.
; void respawn()
: Called by ClientKill() and DeadThink() whenever a player dies. Spawns ragdolls in multiplayer, reloads the last saved game in singleplayer.
; const char* GetGameDescription()
: Returns the descriptive name of the .dll (e.g. Half-Life or Team Fortress 2).
; CBaseEntity* FindEntity()
: Called when the !picker targetname is invoked.
; void ClientGamePrecache()
: Precache function for the player. 
; void GameStartFrame()
: Entry point for game-specific code that needs to run once per frame. Use with caution.
; void InstallGameRules()
: Decides which GameRules to use. Use CreateGameRulesObject( string ClassName ) to do this.
== Game loop ==
(Adapted from this report by James Gadbury) (2023-02-13: Dead link. Direct download here)
* CServerGameDLL::GameFrame()
** GameStartFrame()
** Physics_RunThinkFunctions() - Runs the main physics simulation loop against all entities except players
*** Physics_SimulateEntity(player)
**** CBasePlayer::PhysicsSimulate()
**** CBasePlayer::PlayerRunCommand() - 
***** CPlayerMove::RunCommand()
****** CPlayerMove::StartCommand()
****** CBasePlayer::PreThink()
****** CBasePlayer::Think()
****** CPlayerMove::SetupMove() - applies a usercmd
******* CGameMovement::PlayerMove()
******* CGameMovement::FullWalkMove()
****** CPlayerMove::FinishMove()
****** CBasePlayer::PostThink()
****** CPlayerMove::FinishCommand()
** IGameSystem::FrameUpdatePostEntityThinkAllSystems() - 
** g_pGameRules->EndGameFrame()
Category:Programming
Game intro viewpoint

== Entity description ==
This marks a viewpoint in the intro camera for Team Fortress 2 players.
Creates a "camera" from whose perspective you get images displayed as long as you have no team joined. With several game_intro_viewpoints all appear for a certain time in turn.
:
==Keyvalues==
:* 0 : None (Shared)
:* 2 : Red
:* 3 : Blue
==See also==
Info observer point
Game money

==Entity Description==
An entity that can add or deduct money from players or teams.
== KeyValues ==
== Inputs == 
== Outputs == 
== FGD Code ==
This code belongs to Counter-Strike Global Offensive/bin/csgo.fgd.
@PointClass base(Targetname) iconsprite("editor/game_money.vmt") = game_money : 
	"An entity that awards money to a specific team." 
[
	Money(integer)		: "Amount of money to add (+/-)" : 1000
	AwardText(string)	: "Award Text" : : "The text that will print in the chat next to the award amount. Will look like this:	'1000: <Award Text>'"
	
	// Inputs
	input SetMoneyAmount(integer) : "Set the money value that will be awarded. (without awarding it)" // changed type from 'void' to 'integer'
	input AddTeamMoneyTerrorist(void) : "Add money to players on team TERRORIST."
	input AddTeamMoneyCT(void) : "Add money to players on team COUNTER TERRORIST."
	input AddMoneyPlayer(void) : "Add money directly to the player activating this entity. (no chat description)"
	input SpendMoneyFromPlayer(void) : "If the player has [money amount] or more, take [money amount] away."
	
	output OnMoneySpent(void) : "Fires when input SpendMoneyFromPlayer succeeded."
	output OnMoneySpentFail(void) : "Fires when input SpendMoneyFromPlayer failed. (Player didn't have enough money)"
]
Game player equip

__TOC__
==Entity description==
It spawns one or more entities at the location of the player. Used in multiplayer games to automatically equip the players with standard gear on map spawn, including a multitude of things like weapons, ammo and items. In Half-Life 2 single player, this entity must instead be triggered to spawn its contents with the Use input. This entity requires a few steps to use properly; first you have to tell it what to equip, and then how.
==== What to equip ====
To properly use the entity, turn SmartEdit off and add new keyvalues manually. The key name should be the item; the value should be the number of that item to equip. For example, a key-value pair of "weapon_ar2" and "1" will make the game_player_equip equip the player with a pulse rifle.
==== Activation ====
In multiplayer, simply having this entity anywhere in a map will automatically activate it every time a player is spawned into the map, for the spawning player. This is not supported in singleplayer.
You can also trigger this entity to spawn with the Use input, making it spawn at the location of the activating player only. (To prevent a triggerable game_player_equip from also being activated at player spawn in multiplayer, set the Use Only flag.) The default .fgd does not contain this input, so you must manually enter Use into the Input field instead. Hammer won't register this as a correct input, displaying it in red, but it is correct.
== Keyvalues ==
== Flags ==
== Inputs ==
== See also ==
* Weapons
* Items
Game scavenge progress display

When turned on it displays the number of gas cans poured into entities in the current round on the upper part of the screen as <number_of_cans_filled> / <Max>. Number of filled cans cannot be decreased using available inputs but it's possible with vscripts. Turning it off and back on won't nullify the amount.
== Keyvalues ==
== Inputs ==
== Vscript Enhancement ==
Script example to increment/decrement or reset the counter. When this script is used as this entity's Entity script it sets FireUser1 input to increment the counter, FireUser2 to decrement the counter and FireUser3 to reset the counter to 0. 
== See also ==
* 
*
Game text

Category:GUI Entities
 
This entity displays text on player's screens. This text can be defined directly in the Hammer editor (unlike the similar entity, which uses the titles.txt file). In multiplayer games, the text will normally only display for the activator of the "Display" input. The "All Players" flag can be ticked in order to display on the screens of all players.
__TOC__
== Caveats ==
Game_text works as a HUD element, specifically, a element, defined in . 
Because it was created aiming at low-resolution monitors (owing to Source's age), it is by default restricted to scaling based on 640x480 resolution.
This causes it to scale incorrectly at resolutions higher than 1920x1080. Text will be much larger and some text will be hidden.
It also causes it to only use a limited region of the screen for drawing, and long lines of text, or text near the edges, get cropped on widescreen. This affects other text that uses , such as the infamous "A. I. Disabled" message. 
== Flags ==
== Keyvalues ==
:
:*0: Fade In/Out. The whole text is faded in, and then faded out.
:*1: Credits 
:*2: Scan Out. The text is scanned in letter by letter, and the whole text is then faded out.
:*0: Channel 0 (may be used by some HUD elements) 
:*1: Channel 1
:*2: Channel 2 ( Small text size)
:*3: Channel 3 ( Large text size)
:*4: Channel 4
:*5: Channel 5 (may be used by some HUD elements) 
== Inputs ==
== See also ==
* - Displays a custom HUD message with icons on a specified team's screen.
* - A similar entity that displays a custom message in the world with far more flexibility.
* - A similar entity that points to a specified location in the world.
* - Displays a custom HUD message. Commonly used to show key-binds. 
* - Displays a pre-defined message on the players screen.
* - A similar entity that displays a small custom message at a specific position in the game world.
* Customizable triggered HUD-message - How to create a new entity that is similar to game_text but can receive the message string via a triggered input.
== References ==
# Left 4 Dead 2, the feature is not functioning. Here is a technical explanation for this issue.
Game text (GoldSrc)

This entity displays text on player's screens.
==Key Values==
:
#	Name 	Description
0	Fade In/Out	The whole text is faded in, and then faded out.
1	Credits 	
2	Scan Out 	The text is scanned in letter by letter, and the whole text is then faded out.
 
}
: Channel 0 to Channel 4
== Flags ==
Category:Entities
Game text tf

Similar to , it is an entity that displays text on players' screens. The text is displayed in a colored box with an optional image texture next to it. This text can be defined directly in the Hammer editor. This entity is suitable for standalone maps, if they are not to be localized.
== Keyvalues ==
:* 0 : Everyone
:* 2 : Red Team Only
:* 3 : Blue Team Only
:* 0 : Grey
:* 2 : Red
:* 3 : Blue
== Inputs ==
Game ui

:Not to be confused with GameUI.
__NOTOC__
 It redirects important player key presses to a series of outputs, and can be used to make the player control vehicles built in a map. It can be activated with I/O, or by the player looking at it.
== Keyvalues ==
:*1.0 = straight ahead
:*0.0 = +/- 90 degrees
:*-1.0 = all directions
== Flags ==
== Inputs ==
== Outputs ==
The player is always the !activator.
::
:* -1.0 = +moveleft / +back at 100% speed
:* 0 = no movement in this axis
:* +1.0 = +moveright / +forward at 100% speed
:* 1.0 = trigger is 100% depressed
:* 0 = trigger is at rest
::
Category:Level Design