Cubemaps

Todo: Needs info about Source 2 cube maps. See Draft:Cubemaps (Source 2).

An example of specular reflections on some models (exaggerated through r_showenvcubemap).

A cubemap is a texture that represents a three-dimensional rendering of an area. Source uses env_cubemap entities as sampling points to generate these textures, which are then integrated into the map file. Cubemaps, when built, are reflected on materials that use the $envmap parameter (surfaces such as reflective glass, tiles, water, etc.) A map without built or existing env_cubemap entities will instead use other kinds of "reflections" that don't properly depict it.

Building cubemaps

Building cubemaps is the process of generating textures to use as reflections. For technical reasons, this process isn't automated (Except in ) and is up to the user to do so; until then, existing env_cubemap entities will remain unused and the map, depending on the game, will display either generic, black texture (which basically make it look the same as mat_specular/reflections being disabled) or "missing" textures as reflections due to nonexistent cubemaps.

Warning:

• FOR PEOPLE WITH EPILEPSY: Building cubemaps on games running on Vulkan, such as Left 4 Dead 2, causes the screen to flash black and white violently. Also on systems with faster CPU/GPU (while running the game on lower resolutions such as 1080p instead of 4K), building HDR cubemaps even with Direct3D 9/DX9, will also flash the screen black and white repeatedly.
• If the nav_show_ladder_bounds command was used before building cubemaps, the green boxes will also be baked into the cubemap.
• If you are building cubemaps for Half-Life 2 (except episodes) after the 20th Anniversary Update, you must launch the game with -game hl2 command line argument. Otherwise the game would attempt to access the episodic/maps () map directory instead of Half-Life 2 one, causing the game failing to save the built cubemaps into the map. Similarly, if you are building cubemaps for maps that are located in Episode One's or Episode Two's directory, launch the game with -game episodic (for EP1) or -game ep2 (for EP2) respectively (or launch Episode One/Episode Two through Steam > Tools). Additionally, you must remove NPCs such as npc_combine_camera (using ent_remove_all npc_combine_camera), to prevent its sprite lights baked into the cubemap.

Before building

This article or section needs to be cleaned up to conform to a higher standard of quality because:

Modern Source games, namely Portal 2 and P2:CE, do not need all these complicated params and steps, at least in my experience -Equalizer (talk) 10:56, 22 March 2024 (PDT)

Also some Source games (such as CS:S and HL2), doesn't appear to require cheats to be enabled to build cubemaps. -leonidakarlach (talk) 02:50, 25 August 2024 (PDT)

For help, see the VDC Editing Help and Wikipedia cleanup process. Also, remember to check for any notes left by the tagger at this article's talk page.

Important:Maps for Source 2013 games and others, such as Counter-Strike: Source, are known to include pre-built, blank cubemaps after being compiled (even if there are no env_cubemap entities in them); it is recommended (but not required) that these should be deleted before building new ones, as detailed here. This is fixed in Mapbase.

Tip:

• env_cubemap entities allow for generating higher- or lower-quality reflections, though the game's texture quality also comes into play; consider maxing out your game's visual settings before building cubemaps.
• To build cubemaps, your game's screen resolution needs to be at least 4 times higher than the highest size of an existing env_cubemap, or else attempting to build them will either fail or even cause the game to crash.
  For example, if the highest env_cubemap sizes 128x128, a resolution no lower than 512x512 will be required. (128 × 4 = 512 -> 720x576 (as a valid resolution) or higher)
  Note:The game may appear to freeze or become unresponsive during the process, and the amount of time depends on various factors. For successful results, don't switch away from the game until it's done.
  Also, if you have the game running on windowed/borderless windowed mode, clicking on the game while building cubemaps will cause the windows to freeze with "Not Responding" on the titlebar (even through the game is still building cubemaps). To avoid this, it's highly recommended that you run the game in (exclusive) fullscreen mode.
• Running the game at lower resolution (while making sure your screen resolutions are 4 times larger) can speed up building cubemaps progress.

• If you have other anti-aliasing methods (such as SGSSAA, OGSSAA/SSAA, etc.) forced through GPU driver, other than in-game MSAA/FXAA and/or driver FXAA, please disable them and enable the in-game MSAA/FXAA instead to avoid cubemaps being slowly built. This also applies to running the game at higher resolutions (such as 4K), which will cause cubemaps to be slowly built on weaker hardware. Running the game at lower resolutions (like 1080p) and/or disable AA (other than in-game AA), will significantly speed up building cubemaps progress.
• If you are using Mapbase, you can add -autocubemap to your command line in Hammer. The game will automatically build cubemaps
• Slammin' VBSP features the -nodefaultcubemap command, which skips automatically generating skybox cubemaps on map compile.

LDR

Note:This step doesn't apply to Left 4 Dead nor Counter-Strike: Global Offensive as their maps are compiled in HDR mode only. While Portal 2 does support LDR, the game uses HDR by default, so we recommend building cubemaps in HDR only.

Building cubemaps in a map compiled in LDR (Low Dynamic Range) mode will generate textures only for that mode, regardless of your game's High Dynamic Range video setting. To build the cubemaps, submit the following commands into the game's console:

Command	Description
mat_specular 0	Turns reflections off, which is necessary if using only one iteration of buildcubemaps. It also meant that disabling reflections would avoid some case where missing textures or default cubemap texture (materials/engine/defaultcubemap.vtf, aka a desert with orange sunset sky), might ended up reflected on the cubemap itself.
map map_name	Loads the map; replace "map_name" with the map's actual name
sv_cheats 1	Enables the use of cheat commands; required to build cubemaps Note:Half-Life 2 and Half-Life 2: Deathmatch (since 20th anniversary), doesn't require cheats to build cubemaps, so this step can be skipped. In Counter-Strike: Source, buildcubemaps can be also built without enabling cheats, however, mat_reloadallmaterials (command that requires sv_cheats 1) must be run once in order to display the newly built-cubemaps, since cubemap textures may not be automatically loaded when you load up the map manually. Confirm if other games also require cheats to build cubemaps.
buildcubemaps	Begins building cubemaps. Optionally, specify the number of iterations (e.g.: buildcubemaps 2 (default is 1))
disconnect	Unloads the map and returns to the main menu
mat_specular 1	Turns reflections on, then follow the step below, or optionally you can repeat the process again by following instructions on Improve reflections by rebuilding cubemaps.
map map_name	Loads the map again, your cubemaps should display after doing these steps.
mat_reloadallmaterials (requires sv_cheats 1)	In some games, such as Counter-Strike: Source, if it doesn't display the new cubemap after to loading the map, run this command to display the newly-built cubemaps. This command may run automatically when you load up the map while cheats is already enabled.

LDR + HDR

Building cubemaps in Source 2006 - Source 2013 game, with a map compiled with HDR support needs to be performed twice - once for each mode (HDR and LDR). As opposed to an LDR map's case, your game's High Dynamic Range video setting has to be set to "Full" to build HDR cubemaps, and to "None" to build LDR ones (or using the mat_hdr_level command. To build the cubemaps for both LDR + HDR, submit the following commands into the game's console:

Note:Maps built on Left 4 Dead, or later (and some third-party Source games), does not requires building cubemaps on LDR. See #HDR

Command	Description
mat_specular 0	Turns reflections off, which is necessary if using only one iteration of buildcubemaps. It also meant that disabling reflections would avoid some case where missing textures or default cubemap texture (materials/engine/defaultcubemap.vtf, aka a desert with orange sunset sky), might ended up reflected on the cubemap itself. Note:This command is flagged as "launcher"-only in Left 4 Dead 2, but with VScript you can run script Convars.SetValue("mat_specular", "0") instead.
map map_name	Loads the map; replace "map_name" with the map's actual name
sv_cheats 1	Enables the use of cheat commands; required to build cubemaps Note:Half-Life 2 and Half-Life 2: Deathmatch (since 20th anniversary), doesn't require cheats to build cubemaps, so this step can be skipped. In Counter-Strike: Source, buildcubemaps can be also built without enabling cheats, however, mat_reloadallmaterials (command that requires sv_cheats 1) must be run once in order to display the newly built-cubemaps, since cubemap textures may not be automatically loaded when you load up the map manually. Confirm if other games also require cheats to build cubemaps.
building_cubemaps 1	Sets HDR exposure to a consistent value. This will automatically reset back to 0 after cubemaps are built. Note:This command is flagged as "launcher"-only in Left 4 Dead 2, but you can use the script Convars.SetValue("building_cubemaps", "1") command instead.
buildcubemaps	Begins building cubemaps. Optionally, specify the number of iterations (e.g.: buildcubemaps 2 (default is 1))
disconnect	Unloads the map and returns to the main menu
sv_cheats 0	Disables cheat commands; prevents command mat_reloadallmaterials from unnecessarily self-executing (which briefly freezes the game)
mat_hdr_level 0	Switches to LDR mode (from HDR); submit mat_hdr_level 2 instead if LDR cubemaps were built first
map map_name	Loads the map again to build cubemaps for the new mode
sv_cheats 1
buildcubemaps	Begins building cubemaps for the new mode
disconnect
mat_specular 1	Turns reflections on, then follow the step below, or optionally you can repeat the process again by following instructions on Improve reflections by rebuilding cubemaps.
mat_hdr_level 0/1/2	If necessary, switches back to the mode it was before having submitted mat_hdr_level 0/2
map map_name	Loads the map again, your cubemaps should display after doing these steps.
mat_reloadallmaterials (requires sv_cheats 1)	In some games, such as Counter-Strike: Source, if it doesn't display the new cubemap after to loading the map, run this command to display the newly-built cubemaps. This command may run automatically when you load up the map while cheats is already enabled.

HDR

This section is for games running on the Left 4 Dead engine branch and later, or engine branches that only support HDR (such as Xengine). To build cubemaps in HDR only, submit the following commands into the game's console:

Command	Description
mat_specular 0	Turns reflections off, which is necessary if using only one iteration of buildcubemaps. It also meant that disabling reflections would avoid some case where missing textures or default cubemap texture (materials/engine/defaultcubemap.vtf, aka a desert with orange sunset sky), might ended up reflected on the cubemap itself. Note:This command is flagged as "launcher"-only in Left 4 Dead 2, but with VScript you can run script Convars.SetValue("mat_specular", "0") instead.
map map_name	Loads the map; replace "map_name" with the map's actual name
sv_cheats 1	Enables the use of cheat commands; required to build cubemaps Note:Half-Life 2 and Half-Life 2: Deathmatch (since 20th anniversary), doesn't require cheats to build cubemaps, so this step can be skipped. In Counter-Strike: Source, buildcubemaps can be also built without enabling cheats, however, mat_reloadallmaterials (command that requires sv_cheats 1) must be run once in order to display the newly built-cubemaps, since cubemap textures may not be automatically loaded when you load up the map manually. Confirm if other games also require cheats to build cubemaps.
building_cubemaps 1	Sets HDR exposure to a consistent value. This will automatically reset back to 0 after cubemaps are built. Note:This command is flagged as "launcher"-only in Left 4 Dead 2, but you can use the script Convars.SetValue("building_cubemaps", "1") command instead.
buildcubemaps	Begins building cubemaps. Optionally, specify the number of iterations (e.g.: buildcubemaps 2 (default is 1))
disconnect	Unloads the map and returns to the main menu
mat_specular 1	Turns reflections on, then follow the step below, or optionally you can repeat the process again by following instructions on Improve reflections by rebuilding cubemaps.
map map_name	Loads the map again, your cubemaps should display after doing these steps.
mat_reloadallmaterials (requires sv_cheats 1)	In some games, such as Counter-Strike: Source, if it doesn't display the new cubemap after to loading the map, run this command to display the newly-built cubemaps. This command may run automatically when you load up the map while cheats is already enabled.

Building cubemaps in specific games

Black Mesa

To build cubemaps in Black Mesa maps, the game has to be launched with these parameters: -oldgameui -dev -console +r_4way_use_fast_normals 0
Then, load the map, follow the instructions on HDR section.

After building cubemaps, you can proceed to #Improve reflections by rebuilding cubemaps or simply quit the game, then launch the game again without the command line argument.

Half-Life: Source

Note:Some materials/textures in HL:S will use reflections located on environment maps folder instead. So even if you already build cubemaps, it only displays in some materials that use $envmap env_cubemap.

Bug:Building cubemaps in older version of Half-Life: Source is currently not possible as their textures, despite being generated, aren't embedded into the map file afterward.

This is fixed with the Half-Life 2 20th anniversary update, which also applies to HL:S. Issue is not affected on Half-Life Deathmatch: Source.

Workaround:Move the map file into the maps folder of a game in the same engine branch (such as Half-Life 2), build its cubemaps in that game, then move the file back into Half-Life: Source's folder.

  [todo tested in ?]

Half-Life 2

All versions

Bug:NPCs such as npc_combine_camera and npc_turret_ceiling, while completely invisible when building cubemaps, will have it's sprite lights baked into cubemaps.

Workaround:Enable sv_cheats 1 then remove the NPCs above using ent_remove_all npc_combine_camera;ent_remove_all npc_turret_ceiling command before running buildcubemaps.

20th anniversary only

Bug:Building cubemaps in Half-Life 2, Half-Life 2: Episode One and Half-Life 2: Episode Two, after 20th anniversary update, might fail. In Half-Life 2's case, the game may access the wrong directory (example: episodic/maps), instead of hl2/maps, preventing the cubemaps from embedded into the map file.

You may also see this error message generated on the console: vtex failed to compile cubemap! Unable to remove \steamapps\common\half-life 2\episodic\materials\maps\<map name>\<cubemap location>.vtf

Workaround:Launch Half-Life 2 with -game hl2 command line argument (or go to steamapps\common\Half-Life 2 and run hl2.exe directly). For Episodes, launch the game through Steam > Tools (or using -game episodic or -game ep2).

Portal 2

Bug:Building cubemaps in Portal 2 will fail (and may crashes the game) if the map file is not in the highest-numbered DLC folder (dlc2 by default, mods installed will be dlc3 or higher).

Workaround:Move the map to that folder before building cubemaps and, if necessary, edit the "Place compiled maps in this directory before running the game" path in Hammer's Build Programs options so that the map is automatically generated there.

  [todo tested in ?]

Source Filmmaker

Improper rendering of an HDR cubemap's face in Source Filmmaker.

Bug:HDR cubemaps sizing lower than 128x128 built-in Team Fortress 2 and some other games usually display graphical artifacts on reflections due to the last face of each cubemap not rendering properly in Source Filmmaker. While rebuilding cubemaps in it would normally fix the issue, it is currently not possible to do so as Source Filmmaker generates blank textures.

Workaround:If recompiling a special version of an affected map with env_cubemap's now sizing 64x64 (or higher) is not an option, move the map file into Alien Swarm's maps folder, build its cubemaps in that game, then move the file back into Source Filmmaker's folder.

  [todo tested in ?]

Note:Alien Swarm's "gameinfo.txt" file needs to be modified for this procedure so that the game can have access to assets used by other games' maps not to build cubemaps with missing textures or models. The file's "SearchPaths" section should look like this:

"SearchPaths"
{
	"Game"	"|gameinfo_path|."
	"Game"	"swarm_base"
	"Game"	"platform"
	"Game" "..\SourceFilmmaker\game\usermod"
	"Game" "..\SourceFilmmaker\game\tf_movies"
	"Game" "..\SourceFilmmaker\game\tf"
	"Game" "..\SourceFilmmaker\game\hl2"
}

Note: Team Fortress 2 configurations were used for the example; consider replacing game subfolders (only those within Source Filmmaker paths) with the ones needed.

Workaround:Another option is to manually remove the sphere map (face #7) from the existing HDR cubemap textures. See Creating a custom static cubemap texture for more info.
Alternatively, deleting the affected HDR cubemap texture files will cause the LDR versions to be used, which do not suffer from this bug.

Source 2013 MP / Team Fortress 2

Warning: Building cubemaps on a compressed .bsp (in Source 2013 Multiplayer and Team Fortress 2 branch games) will crash the game!

Improve reflections by rebuilding cubemaps

This step is optional but after building cubemaps once and enable reflections (mat_specular 1), you can build cubemaps again to improve reflections. The improvement it makes is only noticeable if the env_cubemap size was increased to higher resolutions and/or there are two reflective surfaces near each other.

To improve reflections, run the following commands:

Command	Description
Follow the same instructions as LDR, LDR + HDR or HDR, up until the building_cubemaps and buildcubemaps command. Make sure mat_specular is set to "0" first.
building_cubemaps 1	Sets HDR exposure to a consistent value. This will automatically reset back to 0 after cubemaps are built. Note:Only use this command if the map is loaded in HDR
buildcubemaps	Begins building cubemaps. Note:Running buildcubemaps with multiple iterations (e.g. buildcubemaps 2-4 or etc..), does not appear to actually improve reflections, it only repeats the buildcubemaps process. To actually improve reflections, you have to disconnect and reload the map before building cubemaps again, this will make sure the map would display the newly built cubemaps.
disconnect	Unloads the map and returns to the main menu (not required on since the map would be reloaded automatically)
map map_name	Loads the map again
mat_specular 1	Turns reflections on.
building_cubemaps 1	Sets HDR exposure to a consistent value again. This will automatically reset back to 0 after cubemaps are built. Note:Only use this command if the map is loaded in HDR
buildcubemaps	Building cubemaps the second time.
disconnect	Once you are done, unloads the map. Alternatively, you can switch to LDR or HDR mode using mat_hdr_level 0/2, then repeat the steps starting from the first buildcubemaps command. You can also optionally repeat the process again multiple times to further improve reflections, but 2 iterations should be enough.
quit	(optional) Exits the game. On some games, relaunching is required to display newly-built cubemaps

1st iteration

2nd iteration

4-8th iteration

Deleting cubemaps

Several tools make it possible to delete unnecessary or outdated cubemaps; BSPZIP is one official, command-line tool which is usually the preferred option for this procedure, allowing for an usage unlikely of corrupting the map file due to misuse. To delete cubemaps, execute the following command within the maps folder:

..\..\bin\bspzip -deletecubemaps map_name.bsp

Note:Replace "map_name" with the map's actual name.

Warning:Deleting cubemaps actually deletes all the texture (".vtf") files currently embedded into the map, so it's recommended not to embed custom textures before deleting cubemaps.

Extracting cubemaps

In cases where a map has to be recompiled with minor changes (and its built cubemaps vanish as a result), extracting them beforehand will make it not necessary to go through the whole cubemap-building process again. To extract cubemaps with BSPZIP, create a folder that will contain the extracted cubemaps inside the maps one, then execute the following command:

..\..\bin\bspzip -extractcubemaps map_name.bsp "foldername"

Note:Replace "map_name" with the map's actual name, and "foldername" with the actual name of the folder to extract cubemaps into.

Embedding cubemaps

For BSPZIP to make a map use extracted cubemaps, create a text file inside the maps folder. The file's content should look like this:

materials/maps/map_name/c-128_384_64.hdr.vtf
foldername\materials\maps\map_name\c-128_384_64.hdr.vtf
materials/maps/map_name/c-128_384_64.vtf
foldername\materials\maps\map_name\c-128_384_64.vtf
materials/maps/map_name/c448_-256_64.hdr.vtf
foldername\materials\maps\map_name\c448_-256_64.hdr.vtf
materials/maps/map_name/c448_-256_64.vtf
foldername\materials\maps\map_name\c448_-256_64.vtf
materials/maps/map_name/cubemapdefault.vtf
foldername\materials\maps\map_name\cubemapdefault.vtf

Note:Replace "map_name" with the map's actual name, the cubemaps' filenames with correct ones, and "foldername" with the actual name of the folder that contains the extracted cubemaps.

A file requires two dedicated lines (paths): the first line represents the path it will use within the map file, whereas the second one is the actual location of the file to embed into the map file. Relative location paths were used for the example, but they can also be Absolute. Once the text file is ready, execute the following command:

..\..\bin\bspzip -addlist map_name.bsp textfile.txt newmap_name.bsp

Note:Replace "map_name" with the map's actual name, "textfile" with the text file's actual name, and "newmap_name" with either the map's actual name, or a new name not to overwrite the original file (and instead create a separate one).

Renaming a map

For built cubemaps to work, they must be located in a folder that is named after the map; this folder is automatically created within the map file during the building process. Renaming the map file will not also rename said folder, and therefore cubemaps will not be accessed. Some third-party apps allow renaming the folder, though it is not advisable to do so as it may corrupt the file. Instead, either delete and then rebuild the cubemaps, or revert the map to its original name.

See also

• env_cubemap
• $envmap
• parallax_obb - For Parallax Corrected Cubemaps.