nyuuzyou/wikis huggingface dataset:
UnlitGeneric

draws an albedo without standard lighting passes. It is used for things like UI images, pure white, and pitch blackness, but also in situations when software lighting is used (like on detail props).
== Supported Parameters ==
=== Basics ===
=== Adjustment ===
=== Transparency ===
=== Texture Organization ===
=== Effect ===
== Additional Parameters ==
== Caveats ==
=== Projected Texture Bugs ===
If a Skybox has an shader applied to it, some visual bugs can occur. Notably, if a projected texture is shone near a Skybox using an shader, the Skybox will appear to ignore surrounding geometry and phase through walls for as long as the projected texture is active.
To fix this, ensure that a sky_camera exists in the world, typically in its own box which exists outside of the rest of the map.
Preferably, use the purpose-built shader instead.
=== Models ===
If this shader is being used on a model, you must specify to prevent errors.
=== Mapbase ===
Unlit materials in Mapbase should have the shader .
Category:Shaders
Category:Stubs
UnlitTwoTexture

* Two base textures are multiplied together and can be transformed independently. (Just like the Multiply blending mode in typical image editors.)
* Unrelated to WorldVertexTransition, which is used for making alpha fading transitions between two base textures on displacements.
Category:Shaders
== Parameters ==
The first Texture that is used, how it is used depends on the effects which are enabled.
By default $basetexture will be multiplied with $texture2.
Second Texture that is used in different ways depending on which effects are used.
By default $basetexture will be multiplied with $texture2.
On the Dangerzone Wave Model, both $texture2 and $basetexture use the 'Beachwaves' Texture.
The 'Beachwaves' Texture uses the RGB channels for different purposes.
* Red Channel : Waves Albedo Texture
* Green Channel : Distortion/Noise for the Red Channel
* Blue Channel : Distortion/Noise for the Red Channel
$texture2 is used for a framebuffer texture.
The result will be blended between Crosshair Texture + CrosshairTint and Crosshair Texture * CrosshairTint using Average Luminance of $texture2 * $CrosshairColorAdapt
===Example===
Stock .vmt
"UnlitTwoTexture"
{
	"$basetexture" "models/props_combine/portalball001_sheet"
	"$texture2" "models/props_combine/portalball001b_sheet"
 	"$model" 1
	"$nocull" "1"
	"$additive" "1"
	"Proxies"
	{
		"TextureScroll"
		{
			"texturescrollvar" "$texture2transform"
			"texturescrollrate" -.2
			"texturescrollangle" 60
		}
	}
}
 
UnlitTwoTexture
{
 "$beachfoam" "1"
 "$basetexture" "models/props/hr_massive/beachwaves/beachwaves"
 "$texture2" "models/props/hr_massive/beachwaves/beachwaves"
 "$additive" "1"
}
 
UnLitTwoTexture
{
"%tooltexture" "effects/smoke_plumes_00"
$basetexture "effects/smoke_plumes_scroll"
$texture2 "effects/smoke_plumes_00"
$translucent 1
$nocull 1
$no_fullbright 1
$nofog 1
$scale "[1 1]"
$scroll "[2 2]"
Proxies
{
LinearRamp
{
resultVar "$scroll[0]"
rate -.01
}
LinearRamp
{
resultVar "$scroll[1]"
rate .035
}
TextureTransform
{
scaleVar $scale
translateVar $scroll
resultVar $basetexturetransform
}
}
}
== See also ==
*LightmappedTwoTexture
UnrealMapDrawTool

__NOTOC__
UnrealMapDrawTool is a map painting tool. Using only one mouse possible to create maps like small aim_ or big corridors. Using multiple layers possible to create more harder maps.
==Features==
* Support multiple layers map painting
* Own .umd map format to save/load maps
* Create entities like player start positions, water and others
* Also has plugin for (Import .umd directly in J.A.C.K.)
* Any map can be exported to .umd using 
== Drawbacks ==
* No preview map in real time in 3D
* No tools like Paint (line, radius, etc..)
==Media==
File:Draw menu.png|Main editor window
File:Main menu.png|Startup editor menu
==System requirements==
==External links==
* GitHub Repository
* GameBanana
Category:Third Party Tools
Category:Half-Life
Unreal Demo Scanner

The Unreal Demo Scanner is tool for the Goldsource engine demo analyzing and detect hack like AIMBOT or BHOP in .dem files.
== Unreal Demo Scanner == 
Unreal Demo Scanner based at VolvoWrench (by Traderain) but is designed only for one, to detect hackers.
Unreal Demo Scanner can detect multiple hacks : BHOP / AIM BOT / TRIGGER BOT / STRAFE EMULATOR / FAST RUN and more other.
== Developer ==
* Karaulov
== External links ==
* Download Unreal Demo Scanner source code and releases from GitHub
Unseelie

Unseelie is a single player conversion for Half-Life 2 that engages the player in a third person action-adventure quest to save a magical forest overrun with evil Unseelie.
Using the elemental abilities of fire and ice, the player beats back the Unseelie and their blight infestation. The player uses knowledge of the elements to pass through environmental puzzles and destroy enemies.
== External links ==
* Homepage at Guildhall
* "MiniMortem"
* Download
** HLPortal mirror
Updateitem2

It was added in the March 1, 2010 update. It is an Aperture Science Radio set to 85.2 FM. Plays an up-beat instrumental version of Still Alive until moved near an updateitem1, where it will start to play a Morse Code or SSTV transmission. The entity is automatically placed and configured in code based on the map name, and does nothing if placed manually through Hammer.
== See also ==
* 
*
Upgrade ammo explosive

This entity will spawn an already deployed box of explosive ammunition, which will still only allow four uses.
==FGD Code==
To add this entity to the FGD, and to use it in Hammer, add the following lines to the left4dead2.FGD (or any custom FGD, loaded by Hammer).
@PointClass base(WeaponSpawnSingle) studioprop("models/props/terror/exploding_ammo.mdl") = upgrade_ammo_explosive : "Deployed Upgrade Pack - Explosive" []
== See Also ==
* 
* 
*
Upgrade ammo incendiary

This entity will spawn an already deployed box of incendiary ammunition, which will still only allow four uses.
==FGD Code==
To add this entity to the FGD, and to use it in Hammer, add the following lines to the left4dead2.FGD (or any custom FGD, loaded by Hammer).
@PointClass base(WeaponSpawnSingle) studioprop("models/props/terror/incendiary_ammo.mdl") = upgrade_ammo_incendiary : "Deployed Upgrade Pack - Incendiary" []
== See Also ==
* 
* 
*
Upgrade spawn

It is a configurable spawner for weapon upgrades.
== Keyvalues ==
== Flags ==
==Optional FGD edits, for better usability==
This entity will spawn a random chosen upgrade, yet you cannot decide its exact rotation. To fix this, modify "Left 4 Dead 2\bin\left4dead2.fgd".
Search for 
@PointClass base(Targetname) = upgrade_spawn
and modify it as such:
 @PointClass base(Targetname, Angles)studioprop() = upgrade_spawn
 [
 	laser_sight(integer) : "Laser Sight" : 1
 	upgradepack_incendiary(integer) : "UpgradePack - Incendiary" : 1
 	upgradepack_explosive(integer) : "UpgradePack - Explosive" : 1
 	
 	spawnflags(Flags) =
 	[
 		1 : "Enable Physics on spawned item" : 0
 		2 : "Spawned Item Must Exist" : 0
 	]
 	model(choices) : "Helper Model (Visual aid only)" : "models/w_models/weapons/w_laser_sights.mdl" =
 	[
 
 	"models/w_models/weapons/w_laser_sights.mdl" : "Laser"
 	"models/w_models/weapons/w_eq_explosive_ammopack.mdl" : "Explosive Ammo"
 	"models/w_models/weapons/w_eq_incendiary_ammopack.mdl" : "Incendiary Ammo"
 	]
 ]
Uplink Source

Uplink Source is a third party total conversion of the Half-Life demo (Half-Life: Uplink). The main goal of this project is to recreate the original from A to Z, taking full advantage of the Source engine features.
== Features ==
Total remake of:
* All of the four maps, including the training course
* Materials using high resolution textures, physics and sounds
* Objects with lots of polys
* Animated characters and aliens
* Sounds and voices
* New soundtrack
== Story ==
The player takes control of Gordon Freeman 48 hours after the "containment failure", according to a caption. A scientist and a security guard wish to enter the Lambda complex and escape, but they cannot open the reactor door until a signal is sent to the United States Nuclear Regulatory Commission (USNRC), and the radio antenna must be reconfigured manually. To this end, they enlist the player's aid, sending him through an area heavily populated with military personnel and Vortigaunts; having reconfigured the antenna, the player must navigate through an underground maze populated by headcrabs and zombies.
Arriving back at the starting point, the player passes through the previous area, fighting against headcrabs, zombies, and now houndeyes, only to become trapped in a large room with a Gargantua, which proceeds to kill everyone there before homing in on the player. The G-Man is seen watching from a window high on the wall. The screen then fades to black, accompanied by the caption: Current evaluation: uplink completed. Require further data.
To be continued ...
== Media ==
Image:Keypad.jpg|Keypad
Image:B0a1_001.jpg |B0A1
Image:B0a1_002.jpg |B0A1
== External links ==
* Uplink Source - The Official Website.
* 
* 
Uplink Source on French websites :
* Uplink Source on Vossey.com
* Uplink Source on Half-Life Fusion
* Uplink Source on Pmods
Category:Single Player Mods
Use

All entities have a Use input, though many do nothing in response to it. Typically, it performs the action players most expect when interacting with the entity (e.g., opening/closing a door, picking up a physics object). There are four methods to invoke it:
#A player looking at the entity and using the +use console command (commonly bound to the key).
#An entity output that specifies the Use input, or not specifying any input.
#Directly calling the C++ function.
#If an entity without a use function is parented to one which does, it will passthrough the input to the parent.
==Programming==
Although there is always a Use input, the actual Use function of an entity starts null. It can be assigned at any time with SetUse( void *SomeFunc(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) ).
It doesn't appear possible to specify USE_TYPE or value through the I/O system.
Category:Level DesignCategory:Programming
UserCmd strings

This modification allows a mod to send messages from the client to the server without using commands. This allows for a more secure method of communication from the client to the server. A possible implementation would be with VGUI Screens.
==Changes==
===UserCmd.cpp===
#include "baseplayer_shared.h" before memdbgon.h
Note how WriteUsercmd only writes data if there is a delta (change). Notice how the count is tested, the data is then sent, and all of the saved data is then purged. This means only delta data will be sent.
====WriteUsercmd====
At the end:
 #ifdef CLIENT_DLL
 	CBasePlayer *pLocalPlayer = CBasePlayer::GetLocalPlayer();
 	byte count = pLocalPlayer->GetUserDataCount();
 	if(count)
 	{
 		buf->WriteOneBit( 1 );
 
 		buf->WriteByte(count);
 
 		for(byte x=0;x<count;x++)
 		{
 			buf->WriteString(pLocalPlayer->GetUserData(x));
 		}
 
 		pLocalPlayer->ClearUserData();
 	}
 	else
 	{
 		buf->WriteOneBit( 0 );
 	}
 #endif
====ReadUsercmd====
 void ReadUsercmd( bf_read *buf, CUserCmd *move, CUserCmd *from, CBasePlayer *pPlayer /*= NULL*/ )
At the end:
 	if( buf->ReadOneBit() )
 	{
 		int count = buf->ReadByte();
 		for(int x=0;x<count;x++)
 		{
 			bool bOverflow = false;
 			char *cmd = buf->ReadAndAllocateString(&bOverflow);
 			Assert(!bOverflow);
 #ifndef CLIENT_DLL
 			Assert(pPlayer);
 			pPlayer->EvaluateUserData(cmd);
 #endif
 			delete cmd;
 		}
 	}
====UserCmd.h====
 //Forward declaration.
 class CBasePlayer;
 void ReadUsercmd( bf_read *buf, CUserCmd *move, CUserCmd *from, CBasePlayer *pPlayer = NULL );
====Changes to gameinterface.cpp====
 ReadUsercmd( buf, to, from, pPlayer );
==Implementation==
===C_BasePlayer===
*protected CUtlLinkedList<const char *, byte> m_UserData stores all of the data to send (The player should never have to send over 255 strings for 1 usercmd).
*public void AddUserData(const char *pNewData) adds data to send.
*public byte GetUserDataCount(void) returns m_UserData.Count().
*public const char *GetUserData(byte index) returns m_UserData.Element(index).
*public void ClearUserData(void) calls m_UserData.PurgeAndDeleteElements(). See strdup to make sure you don't accidentally get any null pointers.
===CBasePlayer===
*public void EvaluateUserData(const char *pData) evaluates what to do with the command stored in pData.
Category:Networking
Category:Tutorials
Usercmd

CUserCmd ("user command") is the networkable representation of the player's input, including keys pressed and viewangle. By default, updates are sent from client to server at a rate of 30 per second (cl_cmdrate) in the form of delta-compressed usercmds. Delta compression and decompression are handled in WriteUsercmd and ReadUsercmd.
== Production ==
Usercmds intended for transmission to the server are created when the engine invokes IBaseClientDLL::CreateMove (once per tick). The usercmds created are stored in a circular buffer (CInput::PerUserInput_t::m_pCommands) until the engine invokes IBaseClientDLL::WriteUsercmdDeltaToBuffer to compress and serialize them to the server.
The current client mode is also given a chance to manipulate the newly created usercmd via IClientMode::CreateMove. The default implementation (ClientModeShared::CreateMove) delegates to the local player via C_BasePlayer::CreateMove, which in turn passes the usercmd to CBaseCombatWeapon::CreateMove on the active weapon.
The default implementations of both of these IBaseClientDLL methods in class CHLClient delegate almost all of the work to the IInput interface.
== Consumption ==
=== Server ===
The incoming usercmds are consumed on the server when the engine invokes IGameServerClients::ProcessUsercmds. This method handles decompressing the delta usercmds, and then dispatches them to CBasePlayer::ProcessUsercmds. The player caches each such batch of commands together in a CCommandContext object to be processed later.
Once IServerGameDLL::GameFrame is called, the player's PhysicsSimulate method executes the cached usercmds via CBasePlayer::PlayerRunCommand. From here, the active CPlayerMove-derived class executes (pre/post)think for the player, as well as populating g_pMoveData and executing IGameMovement::ProcessMovement for the player.
=== Client ===
The code path for most things that occur during client prediction is very similar to the equivalent server code path, but the entry point from the engine is IPrediction::Update.
CPrediction::RunSimulation invokes the client implementation of C_BasePlayer::PhysicsSimulate on the local player. From here, the player calls back into CPrediction::RunCommand, which very closely mirrors the server PlayerRunCommand functionality: pre-think, think, game movement, and post-think are all executed for the local player using the values from the outgoing usercmd (stored in C_BasePlayer::m_CommandContext).
== See also ==
* Source Multiplayer Networking
* UserCmd strings
Category:Networking
Userid

A userid is a unique integer given to each player who connects to a server. Numbers are assigned sequentially, starting from 1, and never re-used.
IDs are chiefly used to identify players in events.
== Usage ==
IDs are assigned by the engine, and cannot be changed.
* engine->GetPlayerUserId(edict_t*)
* player_info_t::userid
* IPlayerInfo::GetUserID()
Category:Programming
Category:CBasePlayer
Using S&box

== Getting Started ==
When you first boot into the developer tools in S&Box you will see the main window, this has all the tools you need to make a Source 2 Project. From the top left going down are (in order) Hammer, The Material Editor, ModelDoc, The Animgraph Editor, The Particle Editor, The Hotspot Editor, The Postprocessing Editor, S2FM, and FacePoser. As well as The Shader Graph, Widget Gallery, and Launch Config. 
Right next to the toolbar is the Explorer, which is used to make and publish gamemodes, maps, tools, content, add-ons, and libraries. In the top right corner of the explorer window is a plus sign. When you click it, you can choose the copy an existing project off of asset.party, load a S&Box project that you have on your drive, or create a new project.
If you choose to create a new project you will be presented with a menu that looks like this.
you can choose what type of project you want to create and choose a template to build off of. Upon hitting create it will appear in your explorer window.
Make sure that it's selected in the left corner of the game window.
== Project layout and prebuilt scripts ==
Upon creating your project it will compile. You can then right-click on it in the Explorer and go to the location on your computer it is stored on. When you do this it will bring up a windows explorer window that has the files to your project.
Unlike Half-Life:Alyx's tools there is only one folder so everything will be stored in here. (In an empty project) you should see a folder named code, a .addon file, a .editorcofig and a .gitingore (you can mostly ignore the last two.) In the code folder there are a few scripts to help you get started with your project.
The Game script it's a serverside script that then sends directions to the client. This is used for spawning players, creating huds, and declaring player classes.
Next is the Pawn script. This controls your player. Including movement, what's in their inventory as well as controlling how to handle deaths. (respawns handled in game.cs) and animations.
== Using Hammer ==
Hammer is launched with the toolbar mentioned in getting started. (In the top left corner of the main window). It's used the same as Half-Life:Alyx's Hammer for the most part, but with a different asset browser. (Found at the bottom of the hammer window, It's hard to miss it) here you can search for anything on asset.party or in any of your S&Box Projects and use it in Hammer. Once you build your map and run it, it will be run in the game window on the main window. (The instance of S&Box in the dev tools). 
See Half-Life:Alyx Hammer
== Publishing to asset.party ==
Once you have developed your project like you would any other source mod, you can publish it to asset.party. Just right click on your project and click "Upload to Asset.party"
then follow the on-screen prompts
Category:S&box
V2 Hammer Tutorial Series

The Hammer Tutorial V2 Series tutorials are a series of video tutorials created by TopHATTwaffle. The goal of these tutorials is to teach the proper and correct use of Hammer World Editor. The expected skill level going into the first tutorial is someone with little to no knowledge of level design, then to teach them the skills from basics to advanced. The series uses a class room style teaching method where you build upon what you've learned in previous lessons. Although the tutorials are meant to be watched one after another, you can watch any video to learn the skill in that video.
==List of Tutorials==
*Hammer Tutorial V2 Series #1 "Launching Hammer, initial configuration, making a room"
*Hammer Tutorial V2 Series #2 "Adding a sky to your level"
*Hammer Tutorial V2 Series #3 "Getting intimate with brush tool, and introduction to clipping tool"
*Hammer Tutorial V2 Series #4 "LEAKS"
*Hammer Tutorial V2 Series #5 "Introduction to Props"
*Hammer Tutorial V2 Series #6 "Basic Optimization"
*Hammer Tutorial V2 Series #7 "Vertex Tool, Primitive Prefab Creation"
*Hammer Tutorial V2 Series #8 "Complete Lighting Tutorial"
*Hammer Tutorial V2 Series #9 "Displacements!"
*Hammer Tutorial V2 Series #10 "Adding Water to Your Level"
*Hammer Tutorial V2 Series #11 "Adding Doors to your level"
*Hammer Tutorial V2 Series #12 "Input and Output Overview"
*Hammer Tutorial V2 Series #13 "Creating Custom Textures, Normals, VMTs, Packing a Level's Content"
*Hammer Tutorial V2 Series #14 "Env_Cubemaps, Static Reflections, Reflective Textures"
*Hammer Tutorial V2 Series #15 "Creating a 3D Skybox"
*Hammer Tutorial V2 Series #16 "Adding Fog to Your Level"
*Hammer Tutorial V2 Series #17 "Color Correction"
*Hammer Tutorial V2 Series #18 "Func_Movelinear Basic"
*Hammer Tutorial V2 Series #19 "Parenting, attachment points"
*Hammer Tutorial V2 Series #20 "Func_Rotating, Making fans and things spin"
*Hammer Tutorial V2 Series #21 "Optimization"
*Hammer Tutorial V2 Series #22 "Complete Sound Implementation"
* Hammer Tutorial V2 Series #23 "Content Management, AutoPacking a level"
*Hammer Tutorial V2 Series #23 "Texture Manipulation"
*Hammer Tutorial V2 Series #24 "Infodecal and Info_overlay"
*Hammer Tutorial V2 Series #25 "Hostage + Defusal Game Modes and Radar / Overviews" 
*Hammer Tutorial V2 Series #26 "Will it Blend? Blend Modulate"
*Hammer Tutorial V2 Series #27 "What in TARnation, Terri Auto Radar for CSGO" 
*Hammer Tutorial V2 Series #28 "Introduction to Material Proxies"
*Hammer Tutorial V2 Series #29 "Introduction to VScripting"
==External Links==
*Request a Tutorial from TopHATTwaffle
*TopHATTwaffle's Level Design Website
*Tutorial Queue
VBSP2

An extremely obscure tool, VBSP2 appears to have been a BSP/VMF utility and analysis tool, with support for Windows and Mac. It can be found in the bin folder of Dino D-Day. 
=== Syntax ===
 vbsp2 [options] <vmf or bsp file>
===Options===
;-game
:Overrides the VProject.
;-info
:Spews out CSVs in the BSP's directory containing info on:
:;General BSP info (i.e. size),
:;Brushes,
:;Faces,
:;BSP lumps,
:;Planes,
:;Static props,
:;Textures used,
:;Visibility
:It also produces a text file containing all entities in the level, and their keyvalues.
;-gl
:Dumps a .gl file of the map's brushes, for use with glview.
;-lump <lump id>
:Dumps out the binary contents of the specified BSP lump. 
One of the options other than -game MUST be chosen for VBSP2 to operate.
=== Source Files ===
//portal2/rel_pc/src/public/vbsp2lib/lightmaptransfer.h
//portal2/rel_pc/src/public/vbsp2lib/serializesimplebspfile.h
//portal2/rel_pc/src/public/vbsp2lib/simplebspfile.h
//portal2/rel_pc/src/public/vbsp2lib/simplemapfile.h
//portal2/rel_pc/src/public/vbsp2lib/vbspmathutil.h
//portal2/rel_pc/src/utils/vbsp2/vbsp2.cpp
//portal2/rel_pc/src/utils/vbsp2/vbsp2.vpc
//portal2/rel_pc/src/vbsp2lib/bsp2gl.cpp
//portal2/rel_pc/src/vbsp2lib/lightmaptransfer.cpp
//portal2/rel_pc/src/vbsp2lib/physicsbuild.cpp
//portal2/rel_pc/src/vbsp2lib/physicsbuild.h
//portal2/rel_pc/src/vbsp2lib/serializesimplebspfile.cpp
//portal2/rel_pc/src/vbsp2lib/simplebspfile.cpp
//portal2/rel_pc/src/vbsp2lib/simplemapfile.cpp
//portal2/rel_pc/src/vbsp2lib/vbsp2lib.vpc
//portal2/rel_pc/src/vbsp2lib/vbspmathutil.cpp
== See also ==
*VBSP, Valve's BSP compiling tool.
*VBSPINFO, Valve's original BSP analysis tool.
*VMAP, another obscure tool developed around the same time. Not to be confused with the VMAP file format introduced in Source 2.
VBSP h4xed

is a modified version of designed to greatly increase the maximum width and length of visleaves. It was designed by DeathByNukes to speed up the compilation of large empty maps for and to give mappers greater control of a level's optimization.
Some of its uses have been obsoleted by .
==Links==
*Official Website (No longer exist)
*Source code (Source SDK 2013 version)
*Download (Broken) [mirror #1]
==See also==
*Controlling Geometry Visibility and Compile Times
*Map Compiling Theory
*Visleaf
*VBSP
Category:Third Party Source Tools
Category:Source 1 BSP compilers