Cubemaps

Source Engine

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" (such as default cubemap texture, see below) that don't properly depict it, appear broken (missing textures, reflections appear bright, etc...), or simply doesn't show any reflections (if the cubemap texture is black).

Building cubemaps

This default cubemap texture will appear if you skip building blank cubemaps during VBSP process.

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:

• A blank (black) texture (which basically make it look the same as mat_specular 0 / disabled reflections)
  • During compilation, VBSP will generate blank cubemap textures.
  • If you skip VBSP's blank cubemap generation (either by using Mapbase's VBSP without adding -autocubemap, using Slammin' Source Map Tools VBSP with -nodefaultcubemap, or if you deleted the cubemaps, it will display the missing or generic environment texture instead, and building cubemaps for the first time (without disabling mat_specular) will instead generate blank textures (or partially generate the cubemaps, with some of them being blank), until building it again second time, so don't forget to disable it. mat_specular must be also disabled prior to loading the map, otherwise disabling them after the map have been loaded, will cause buildcubemaps to generate blank textures aswell.
• Default cubemap texture (see image on right)
  • If the cubemap is missing, the game first tries to fall back to LDR cubemaps (and fails), so the game ended up using this texture instead, showing the empty desert with sunset sky as reflections.
• Cubemaps appear bright (HDR only)
  • If HDR version of the cubemap isn't present, the game will fall back to LDR version, which will cause it to appear bright on HDR.
• Missing textures as reflections
  • If the cubemap is missing and the game fails to use the default cubemap texture for some reasons, missing texture will show up as reflections.
  • This also appears if you recompiled the map and overwrite the original which have cubemaps texture baked in, then Alt + Tab ⇆ back to the game (which sometime reloads the textures).

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. Deleting cubemaps is probably not needed (atleast for SP games), since this would require you to use mat_specular 0, otherwise buildcubemaps will instead generate blank texture until you run the command again.
Edit 2: Counter-Strike: Source builds cubemap correctly now without deleting cubemaps after engine update (Team Fortress 2 branch), so some steps can be skipped. -leonidakarlach (talk) 02:50, 25 August 2024 (PDT) - Edited 24 Feb 2025.

Left 4 Dead 2 also does not require anything, other than maybe turning shader quality to medium. But it's not always required. Just loading the map and running Buildcubemaps is often enough. --MrFunreal (talk) 02:23, 11 February 2025 (PST)

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 (including Team Fortress 2 branch) 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). In Mapbase, blank cubemaps are not automatically generated by default.
For Source 2013 Singleplayer and Source 2013 Multiplayer titles (including previous version of Valve games), deleting cubemaps will be required (in order to make sure cubemaps are properly written to the BSP).

Tip:Deleting pre-built blank cubemaps, while not required, is recommended for Left 4 Dead engine branch games or later (and HDR-only games) since VBSP generates blank LDR cubemap textures that increase BSP file size while being unused anyway in those games.

Note:Deleting pre-built blank cubemaps isn't required for Half-Life 2, Portal nor the Team Fortress 2 branch games (, , , and ), since the updated version of those games (as of 2025) now have built and written generated cubemaps to the .BSP correctly. Deleting blank cubemaps is also not required on Source SDK Base 2013 - Multiplayer (also on TF2 branch), but required for Source SDK Base 2013 - Singleplayer, and the legacy version of Source SDK Base 2013 - Multiplayer.

Important:

• 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)
• Disable any anti-aliasing method (SGSSAA for example) forced through GPU driver and enable the in-game AA or use FXAA instead (or simply run the game in Vulkan which will disable all forced AA) 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), and disable any FPS cap, will significantly speed up building cubemaps progress.

Warning:

• EPILEPSY WARNING: Building cubemaps on a faster systems (with high single-thread performance) will causes the top left of the screen (which display captured cubemap images) to flicker much faster. Look away from the screen while the cubemaps are being built.
  • Additionally, the screen will also flashes white when building HDR cubemaps.
  • This mostly doesn't applies to games on Source 2006 or earlier, since these branches doesn't support multi-core and building cubemaps will take little bit longer on these branches.
• If the nav_show_ladder_bounds command was used before building cubemaps, the green boxes will also be baked into the cubemap. The same goes for r_screenoverlay, and most screen space effects.
• While taking damage, building cubemaps when the screen is tinted red/white will cause the red/white tints baked into the cubemap.
• Maps that contains env_credits, like the Half-Life 2 introduction scene seen in d1_trainstation_01 on "Point Insertion" and the HL2 Credits, you must wait for the credits/introduction to end, otherwise building cubemaps will lead to generating blank (black) textures. Use host_timescale console command and temporarily set to high value (like 99) to speed up the introduction scene/end credits, then set host_timescale to 1 and follow the build cubemaps instructions below.
• The game may appear to freeze or become unresponsive during the process of building cubemaps, and the amount of time depends on various factors (amount of env_cubemap(s), cubemap sizes, CPU usage/utilization and framerate). For successful results, don't switch away from the game until it's done.
  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 (exclusively) fullscreen mode.
  For users using Vulkan instead of Direct3D 9 (Windows only): Clicking on the game while building cubemaps, even in fullscreen, will also cause the game to permanently freeze.
• If you are building cubemaps for Half-Life 2 (except episodes) after the 20th Anniversary Update, you must follow the instructions here. Also building cubemaps in Half-Life 2 without removing some NPCs (or switching to a non-Gravity Gun weapon) will cause sprites' light from them to be baked into cubemaps.

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 (set texture, models, shaders, shadow details to High/Very High) before building cubemaps. Higher anti-aliasing settings also makes minor differences (not easily noticable).
• Running the game at lower resolution (while making sure your screen resolutions are 4 times larger) and disabling FPS cap (both in game, graphics driver and software like RTSS) can speed up building cubemaps progress.
• Bind mat_hdr_level 0, mat_hdr_level 2, building_cubemaps 1 to any numpad keys, and buildcubemaps to numpad ↵ Enter key, so you don't have to manually type and submit most of these command on console.

• If you are using Mapbase, you can add -autocubemap to launch the game ($game_exe) command line in Hammer. The game will automatically build cubemaps.
• Slammin' VBSP 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.

Note:Cheats do not have to be enabled to build cubemaps in: Half-Life: Source, Half-Life 2, Half-Life 2: Deathmatch (all three since 20th Anniversary Update), Portal (since May 20, 2025) nor the Team Fortress 2 branch games.

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, and if all cubemaps has been deleted. 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 end up reflected on the cubemap itself. Note:If you let VBSP generate blank cubemaps and you build the cubemaps without this command, it will build (and written cubemaps to BSP) just fine (atleast in ), however, if you deleted the cubemaps and run buildcubemaps, without disable mat_specular, it will instead generate and write blank textures, until you run buildcubemaps a second time. mat_specular must be also disabled prior to loading the map, otherwise disabling them after the map have been loaded, will cause buildcubemaps to generate blank textures aswell.
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, Half-Life 2: Deathmatch (since 20th Anniversary), Portal (since May 20, 2025 update) and all Team Fortress 2 branch games (, , , and ), doesn't require cheats to build cubemaps, so this step can be skipped. In many Source 2013 (SP/MP) games, including previous version of Counter-Strike: Source, buildcubemaps can also be built without having to enable 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 or branch (Source 2013), if it doesn't display new cubemap textures after 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. This command is usually not required on Half-Life 2 (since 20th Anniversary update), Portal (since May 2025 update) nor the Team Fortress 2 branch games, since cubemaps should be automatically reloaded when you load the map.

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

Note:Cheats are not required to be enable to build cubemaps in: Half-Life 2, Half-Life 2: Deathmatch (since 20th Anniversary) and all Team Fortress 2 branch games.

Command	Description
mat_specular 0	Turns reflections off, which is necessary if using only one iteration of buildcubemaps, and if all cubemaps has been deleted. 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 end up reflected on the cubemap itself. Note:This command is flagged as "launcher"-only in Left 4 Dead and Left 4 Dead 2, you can use the following command instead: sm_cvar mat_specular 0 command (with SourceMod installed) or script Convars.SetValue("mat_specular", "0") (using VScript). Note:If you let VBSP generate blank cubemaps and you build cubemaps without this command, it will build (and written cubemaps to BSP) just fine (atleast in ), however, if you deleted the cubemaps and run buildcubemaps, without disabling mat_specular, it will instead generate and write blank textures, until you run buildcubemaps a second time. mat_specular must be also disabled prior to loading the map, otherwise disabling them after the map have been loaded, will cause buildcubemaps to generate blank textures aswell.
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, Half-Life 2: Deathmatch (since 20th Anniversary) and all Team Fortress 2 branch games (, , , and ), doesn't require cheats to build cubemaps, so this step can be skipped. In many Source 2013 (SP/MP) games, including previous version of 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, which will make sure that no cubemaps won't look brighter or darker than others. This will automatically reset back to 0 after cubemaps are built. Note:This command is flagged as "launcher"-only in Left 4 Dead and Left 4 Dead 2, you can use the following command instead: sm_cvar building_cubemaps 1 command (with SourceMod installed) or script Convars.SetValue("building_cubemaps", "1") (using VScript).
buildcubemaps	Begins building cubemaps. Optionally, specify the number of iterations (e.g.: buildcubemaps 2 (default is 1)) In singleplayer games, the map will be automatically reloaded after building cubemaps.
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) or Alt + Tab / Restart game	In some games, such as Counter-Strike: Source, if it doesn't display new cubemap textures after loading the map, run this command to display the newly-built cubemaps. This command may run automatically when you load up the map while server cheats are already enabled. If this command does not reload cubemaps in-game, you can instead try Alt + Tab ⇆'ing while in fullscreen or simply restart the game; the latter method can sometimes reload the texture (and display the new cubemap) aswell. Note:Alt + Tab only works properly in Source 2009 or earlier, and Left 4 Dead engine branch or later. Source 2013 and CS:GO engine branch games use Direct3D 9Ex, which meant that running those games on Windows 10/11, without setting multiple displays to "Duplicate" or disable fullscreen optimization, it will not reload anything at all when you Alt + Tab. Note:Usually not required on Half-Life 2 nor the Team Fortress 2 branch games, since cubemaps should be automatically reloaded when you load the map.

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, and if all cubemaps have been deleted. 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 end up reflected on the cubemap itself. Note:This command is flagged as "launcher"-only in Left 4 Dead and Left 4 Dead 2, you can use the following command instead: sm_cvar mat_specular 0 command (with SourceMod installed) or script Convars.SetValue("mat_specular", "0") (using VScript). Note:If you let VBSP generate blank cubemaps and you build cubemaps without this command, it will build (and written cubemaps to BSP) just fine (atleast in ), however, if you deleted the cubemaps and run buildcubemaps, without disabling mat_specular first, it will instead generate blank textures, until you run buildcubemaps a second time. mat_specular must be also disabled prior to loading the map, otherwise disabling them after the map have been loaded, will cause buildcubemaps to generate blank textures aswell.
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, Half-Life 2: Deathmatch (since 20th Anniversary) and all Team Fortress 2 branch games (, , , and ), do not require cheats to build cubemaps, so this step can be skipped. In many Source 2013 (SP/MP) games, including previous version of Counter-Strike: Source, buildcubemaps can be also built without enabling cheats, however, mat_reloadallmaterials (a 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, which will make sure that one cubemap won't look brighter or darker than others. This will automatically reset back to 0 after cubemaps are built. Note:This command is flagged as "launcher"-only in Left 4 Dead and Left 4 Dead 2, you can use the following command instead: sm_cvar building_cubemaps 1 command (with SourceMod installed) or script Convars.SetValue("building_cubemaps", "1") (using VScript).
buildcubemaps	Begins building cubemaps. Optionally, specify the number of iterations (e.g.: buildcubemaps 2 (default is 1)) In singleplayer games, the map will be automatically reloaded after building cubemaps.
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) or Alt + Tab / Restart game	In some games, such as Counter-Strike: Source, if it doesn't display new cubemap textures after loading the map, run this command to display the newly-built cubemaps. This command may run automatically when you load up the map while server cheats are already enabled. In Left 4 Dead (or some Source games), this command may not reload cubemaps in-game, so instead Alt + Tab ⇆'ing while in fullscreen or simply restarting the game can sometimes reload the texture (and display the new cubemap) aswell. Note:Alt + Tab only works properly in Source 2009 or earlier, and Left 4 Dead engine branch or later. Source 2013 and CS:GO engine branch games use Direct3D 9Ex, which meant that running those games on Windows 10/11, without setting multiple displays to "Duplicate" or disable fullscreen optimization, it will not reload anything at all when you Alt + Tab. Note:Usually not required on Half-Life 2 or all Team Fortress 2 branch games, since cubemaps should be automatically reloaded when you load the map.

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 Half-Life 2's 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.

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.

Bug:Similar to above, if the player equips Gravity Gun, then building cubemaps, it's sprite lights also get's baked into cubemaps.

Workaround:Simply switch to other weapons, or use give console command to give player another weapon. Example: give weapon_crowbar, give weapon_cubemap, etc...

20th Anniversary only

Bug:Building cubemaps in Half-Life 2, Half-Life 2: Episode One and Half-Life 2: Episode Two, after the 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).

Left 4 Dead / Left 4 Dead 2

Left 4 Dead and Left 4 Dead 2 restrict certain console commands, such as mat_specular and building_cubemaps. While it seems to be optional, the latter command is recommended to make HDR cubemap have consistent exposure.

For Left 4 Dead, you must use SourceMod in order to use these commands (since VScript wasn't introduced until L4D2)

sm_cvar mat_specular 0

sm_cvar building_cubemaps 1

For Left 4 Dead 2, you can either use SourceMod or run these VScript command

script Convars.SetValue("mat_specular", "0")

script Convars.SetValue("building_cubemaps", "1")

Additionally, unlike Counter-Strike: Source or other Source branches, mat_reloadallmaterials does not reload the cubemap texture, so after you built the cubemap, you will need to restart the game, or alternatively, while in fullscreen mode, Alt + Tab ⇆ to desktop then back to the game (while the map is already loaded) will reload the cubemap texture in-game.

Portal 2

Bug:Building cubemaps in Portal 2 will fail (and may crash 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.

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 (and restart the game to display new cubemaps) would normally fix the issue, it is currently not possible to do so as Source Filmmaker doesn't built it correctly (all faces will ended up look the same as each other, even if there are multiple env_cubemap entities).

Workaround:If recompiling a special version of an affected map with env_cubemap's now sizing 128x128 (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.

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!

Note:For Team Fortress 2 branch games, deleting cubemaps, and using sv_cheats to build cubemaps are no longer required. However if you are mapping on Source 2013 Multiplayer games (including previous version of Valve games running on Source 2013 Multiplayer branch), you will need to delete cubemaps and enable cheats to build cubemaps.

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, which will make sure that one cubemap won't look brighter or darker than others. This will automatically reset back to 0 after cubemaps are built. Note:Only use this command if the map is loaded in HDR Note:This command is flagged as "launcher"-only in Left 4 Dead and Left 4 Dead 2, you can use the following command instead: sm_cvar building_cubemaps 1) command (with SourceMod installed) or script Convars.SetValue("building_cubemaps", "1") (using VScript).
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 Skip both disconnect and map if the game (usually singleplayer like ) reloads map 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 Note:This command is flagged as "launcher"-only in Left 4 Dead and Left 4 Dead 2, you can use the following command instead: sm_cvar building_cubemaps 1) command (with SourceMod installed) or script Convars.SetValue("building_cubemaps", "1") (using VScript).
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.
map map_name	Loads the map again, it should display the new cubemap textures after doing these steps.
mat_reloadallmaterials or Alt + Tab / Restart game	In some games, such as Counter-Strike: Source, if it doesn't display new cubemap textures after 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. In Left 4 Dead (or some Source games), this command may not reload cubemaps in-game, so instead Alt + Tab ⇆ while in fullscreen or simply restart the game can sometime reload the texture (and display the new cubemap) aswell. Note:Alt + Tab only works properly in Source 2009 or earlier, and Left 4 Dead engine branch or later. Source 2013 or CS:GO engine branch games use Direct3D 9Ex, which meant that running those games on Windows 10/11, without setting multiple displays to "Duplicate" or disable fullscreen optimization, it will not reload anything at all when you Alt + Tab.

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.

Note:Once you delete the cubemaps, building cubemaps again will require mat_specular 0 prior to loading the map, otherwise buildcubemaps will need to be run twice, since it has to generate blank textures first to avoid missing texture/generic textures on reflective surfaces being baked into cubemaps. mat_specular 0 will prevent that from happen, so you just simply run buildcubemaps once.

Deleting cubemaps will also display the message Failed, using default cubemap 'maps/map-name/cubemapdefault' once you load the map with deleted cubemaps.

Note:If you are making maps for HDR-only games (such as Left 4 Dead or games on later branches after Left 4 Dead engine branch), deleting unused blank LDR cubemaps is optional but recommended to reduce BSP file sizes.

Important:It is not required to delete cubemaps on Team Fortress 2 branch games (, , , and ), aswell as Half-Life 2, Half-Life: Source and Portal (all of which, runs on more up to date version of Source 2013 Singleplayer from 2025), since cubemaps are now properly written to the BSP. But if you still encounter the problem, try to delete cubemaps.
Deleting cubemaps is only required on Source 2013 Singleplayer (including Source SDK Base 2013 - Singleplayer, which hasn't been updated since 2014, and mods built on it) and Source 2013 Multiplayer (including legacy version of Source SDK Base 2013 - Multiplayer), Source 2009/Source Multiplayer or earlier.

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

Renaming the map .bsp file breaks cubemaps on non-world geometry (models, props, weapons etc.). When map is being loaded the Source engine loads the Pakfile (containing, amongst others, cubemap textures and patch materials) embedded in the map. To display cubemaps on said geometry the engine searches materials/<MAP BSP FILENAME> directory but if such directory is not found, due to the BSP file being renamed, the cubemaps are not displayed. Cubemaps on world geometry however are not affected, as the internal BSP data still points to a valid materials inside the Pakfile (see TexdataStringData and TexdataStringTable).
BSPEntSpy allows for renaming the internal map structure and data to fix the issues with Cubemaps

See also

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