Before you start making custom textures for your maps, make sure you have the following tools (these are the tools I use when making custom textures) to create custom textures. Although you wont need all of them, having them can make your life and dreams a lot more achievable.

1. VTFEdit [nemesis.thewavelength.net]
   
2. GIMP (optional)[www.gimp.org]
   
3. GCFScape (optional)[nemesis.thewavelength.net]
   
4. SSbump Generator (optional)[sourceforge.net]

VTFEdit will be used for viewing and editing the .vtf and .vmt files
Gimp will be used to easily modify .png files we make (although you can use any image editing program that you're comftorable with.)
GCFScape will be used to extract textures from source games so we can modify them
SSbump Generator will help us generate Normal Maps, and also Height maps.

Once you have all of these, you can continue to the next part of the guide.

Say I wanted to make this full orange color into a texture



So to start, I open up VTFEdit. Click "File", then click "Import". For me, I'm going to go to where my orange color is located on my PC, and then double click it.
Make sure your texture is a size that can be divided by a power of 2 Sizes like 512x512 and 256x128 images will work, but 292x600 or something like 48x72 won't work.

You'll get these list of settings that pop up. For now, we'll just click "OK".


Since we aren't going to change our texture, we're just going to save it. Click "File", then click "Save As". I'll name my file "orange", then click "Save".
We aren't done yet though, custom textures require a .vtf (Valve Texture File) and a .vmt (Valve Material File). Click "Tools" and then click "Create VMT". A menu should pop up.


We won't change much, but the one thing we do want to change is the "Base Texture" parameter. We want to remove everything before the file name, in this case, orange. So our base texture should just be "orange". Now click on "Options".


Here we can change certain values. For my orange texture, we'll be checking off "Translucent" as our texture isn't translucent. We'll also be changing our "Surface 1" parameter to "Concrete". Then click "Create". So now we should have both our .vmt and .vtf files.


To make sure our .vmt is going to work, double click it, and open it up in either VTFEdit or Notepad, or any other text editor.


Since I put a spare version of my files in a different folder, and not the game folders, it gave me the directory from my "Users" all the way down to my "colour" folder. Since hammer will base your texture origin file location off of the materials folder, we're going to get rid of everything except the "orange" part of our $basetexture value.

So now we want to drag both our .vmt and .vtf into our game's "materials" folder.

After all this, now we can go into hammer and create a map using our new texture. For me, +my custom orange texture looked like this in game:


It doesn't look too great, but we're going to do some things to make it look better.

Say I wanted to spray this on a wall.

To start, import the texture into VTFEdit. You'll want to make sure your texture has some sort of transpoarency or an alpha layer.

You'll notice this white and grey checker-board formation where there isn't anything. This is the part of the texture that's translucent. Save the file as a .vtf file.
Now we're going to create the .vmt file. Click "Tools" and then click "Create VMT". Check the translucent box and create.
We'll want to add a few more things to get the texture to work as a decal. to do this, we're going to create some extra lines.
This is what our .vmt file will look like. Now that we have that ready, simply put it in your materials folder of your game, and create a map using it. Note that textures with translucency do NOT block off leaks in your map. This is what my texture looks like in game:

Blend textures a relatively easy to make. The first thing you need are 2 textures you would like to blend together. Here, I'm using a grass texture and a dry grass texture.


To start, we're going to transform these into .vmf files. Then, we're going to create 1 single .vmt file which is going to be for our blend texture. What we should add is something like this:

Note: your texture won't appear to blend when using the Texture Browser.

You can add different surface props using "$surfaceprop2", but for our case, we don't need one since both our textures are grass.
Now, to properly use our custom blend texture, we're going to load up hammer, and use our texture on a displacement. Then, we want to choose the option "Paint Alpha", and it should blend one of our basetexture textures with the other. Our texture looks like this in game:

Lava textures look better when they glow.


It's actually really simple to make a glowing texture. Simply create the .vmt and .vmf file of your texture, but instead of adding parameters to our .vmt file, we're going to go to the .rad file of our game folder.


Open the file up and you'll see a few lines of code.
The first 3 numbers represent the RGB (red, green, blue) values. The fourth value represents brightness. So we're going to insert our lava texture along with these other textures. It's the same location as our $basetexture value.
Now, when we load up our game, our lava texture should be glowing.

(Notice how everything around the lava is glowing orange, yet the lava itself isn't glowing)

You'll need GIMP for this part of the guide

Say I wanted to edit this dev texture from HL2 to be a different color.


We're going to be using GCFScape to extract the texture from a .vpk file in the HL2 folders. We can do this for any source games with .vpk files. To start, open up the .exe of GCFScape.


You'll want to search your game files (in this case, the HL2 files), and find the .vpk files. The ones you're looking for are the files with "_dir" at the end of them. The thing is hl2_textures_dir will give us the .vmf files, and the hl2_misc_dir will give us the .vmt files. W'ere just going to have to manually extract both of them. Double click the files with _dir at the end.


Now that we have all of the texture files extracted,we're now going to open up the .vtf and open up our dev texture we extracted. We're going to click "File" and then "Export". We're going to export it as a.png file. Then we're going to open this file up in GIMP.
We aren't going to do much here. Click "Colors" and then click "Hue Saturation". Here we can change the color of our .png file easily. Here, I've changed it to a blue color. Now we're going to save our new changed texture.
We're going to go through the same processof making a texture. This is how our modified texture looks in game:

A normal map creates the illusion that a texture is 3D but isn't. A comparison of a texture with a normal and one without is massive, especially when viewed with a flashlight or sideways.
Here's an example for a marble floor I generated with SSbump Generator:


VTFEdit can create normal maps, but they usually don't create the best looking or most realistic normal maps. We're going to be using SSbump Generator [sourceforge.net] for creating our normal maps.

If you're using VTFEdit, read this part of the guide
To start, open up VTFEdit and then import an image. You'll want to save this image as a .vtf for now, because you'll need a regular .vtf file and a .vtf file that's a normal map. It's relatively simple to make a normal map, when you import a file, there should be an option to "Generate Normal Map". You'll want to check "Wrap Normal Map", which means that your normal map can be tiled. Once you're happy with your settings, click "OK".
Now you'll want to save your normal map as a .vtf file.

If you're using SSBump generator for this part of the guide, read this part of the guide
To start, open the .exe file in SSBump.


Looking at the top of the program, you'll want to add an image, in this case, the image file for our custom texture. You'll want to make sure it only generates a normal map in the settings. Next, you'll want to build a normal map with it. At the top of the screen, there should be a button to generate a normal map. Click that.


A new set of settings will appear. We'll want to select our image file, and add a layer. A layer can be either Default, Fine Detail, Medium or Large Detail. You can have multiple layers. For us though, we're going to be using Large Detail. Now you'll want to click "Save Height Map". You'll need to save it as either a .jpeg, a .png or a .tga file (Those are the few compatible imports we can do in VTFEDit). And then you want to transform your normal map into a .vtf file.

When you have finished making your normal map, jump to here
Once you have the .vtf file for your normal map and your base texture, create a .vmt file. We'll be adding these parameters to our marble floor texture.

The "$bumpmap" parameter defines the normal map it'll use on our texture. In game, our marble floor looks like this:


(Notice how the reflections on the texture are handled)

Detail textures are used when a player views your texture up close, and the texture seamlessly gets a higher resolution. A good explanation of what it does can be found here. Usually, it's a grayscale image that doesn't really tile. Here's an example of the noise_detail_01 texture from the VDC:


The left texture uses a blend texture, the right texture doesn't.

And to make it useable with a texture, you'll need to add the "$detail" parameters to your texture. A vmt with a working detail texture looks like this:


The $detail parameter says what detail texture should be used.

The $detailscale scales the detail texture to a certain size before it gets tiled again.

The $detailblendfactor specifies the alpha value of you detail texture. usually, 0.8 is a good starting value.

And the $detailblendmode species the way your detail texture should be used with your $basetexture. In this case, 0 is just the normal way of using a detail texture.

Creating a detail texture is very easy. You simply make a grayscale image of something, and then use that texture in your .vmt parameters.

I have a nice Lava texture that we made glowing, but I want it to be scrolling.


To start, we're going to go in the .vmt file and change it. We're going to be adding a "Proxies" tab. There a literal metric ton of Proxies we could add, but we're just going to be adding "TextureScroll" to the Proxies list. Our .vmt file should look like this:

TextureScroll has 2 different things we can change. The texture scroll rate, and the texture scroll angle. The texture scroll rate means how fast our texture scrolls, so the smaller the number, the slower the scroll (values above 2 are still quite fast, so try to stick to 1 or a lower, decimal value). Texture scroll angle means the angle it scrolls at. 90 degrees is sideways.

Sometimes you just need a little rotation. Here's an example of a texture that rotates:

That texture is the helicopter blade on the Hunter Chopper NPC. You might notice we're using texture variables, more on that later.

The LinearRamp proxy makes the value that constantly increases.

And since there is no proxy for defining rotation, like we had with TextureScroll and AnimatedTexture, we're forced to use the "TextureTransform" proxy.

Here's a rainbow texture I want to be animated in game:


Make sure you have all the frames of your animated texture
To start, you'll want to open up VTFEdit. We're going to be importing multiple images at once. To import multiple images, click the "Import" button, and then click all the frames (in order from first to last) holding CTRL on your keyboard. Once you have all your frames selected, you can import them into VTFEdit.
Now save the file as a .vtf file, and then create a .vmt file. We'll be adding these lines of code to the file:

We're using the "$selfillum" parameter because if our rainbow texture we're to be affected by light, it would look pretty ugly. Animated texture frame rate means how fast our textures cycles between frames. 2 is a good starting value. Higher values cycle through frames faster. For example, a value of 10 will mean that the texture cycles to the next frame every 10 frames per second.

Skyboxes are simply the sky that surrounds your level.



Skybox textures consist of 6 different textures, the BK (back), the DN (down), the FT (front), the LF (left), the RT (right) and the UP (top). We just add those two letters at the end of our texture.

Note: that your texture must be in a folder called "skybox".
Note: you'll need to add all the directions across six .vmt files to make the skybox work.

The parameter $ignorez means that your texture will always be in front of anything 3D and behind anything that's part of the skybox. A short explanation can be found here.

The parameter $nofog simply means our texture doesn't get affected by any fog in our map, which is pretty important, believe it or not for making sure your skybox is rendered without fog covering it.

The parameter $hdrcompressedtexture is explained here. In short, it means the
skybox is brighter and has a higher high dynamic range.

And since skyboxes don't have light rendered on top of them, they use the "UnlitGeneric" shader parameter.

Textures can have variables. You simply define something that doesn't do anything by default, for example:

What did we do there? We essentially told source that our texture has something called "$ten" and that has a value of 10. But the thing is, $ten isn't a normal parameter, so it's essentially a variable now.

Now, you might ask: "Why are these even useful?" Here's an example:


What all of this stuff does is that it creates a random number with a scale of 12 to be the frame rate of the texture. The "EntityRandom" proxy generates a random number, so it's useful for creating random things for your texture.

There are many other proxies that can be used for number generation as well.

Custom sprites are like regular textures, except they're used with the env_sprite entity and the env_sprite_oriented entity in hammer. Here's an example of a sprite texture I found with some modifications using GIMP.


Here's what the .vmt file would look like.


What happens in this .vmt file is that we're creating a very flat, inexpenisve 2D texture. You should be able to add or tweak any parameters to your needs. I couldn't figure out what the $spriteorigin parameter does, so you should just leave it to what I made it be.
Note: the paramaters $vertexcolor and $vertexalpha do not work in CS:GO.

Here's a table with all the possible $spriteorientation parameters with descriptions on what they do.

Compile parameters are essentially parameters that start with a % instead of a $. According to the VDC, compile parameters change the vbsp compile behavior of materials. I've created a full table to all or most of the compile paramters and what they do. If the exclusive flag is yes, then it means that only one of the flags can be set on any material. Most of these compile parameters are booleans, which means they can only have a 0 or a 1 as a given parameter.

This is probably one of the most painful things I have ever created. For the sake of preserving my sanity, we're going to use our custom lava texture again.


Water is seperated into 2 catagories, expensive and cheap. Expensive water has real time reflectures, but is very costly to run. Cheap water, uses cheaper reflection (env_cubemaps), which are pretty ugly on water, but require a lot less to run.

The thing is, we're going to need a beneath texture for our water. Usually, it's very similar to the regular texture. It can be an entirely seperate texture to the water itself, and have it's own .vmt file (unlike normal maps). For the sake of time and again, preserving my sanity, we're just going to use the same surface texture.

There's going to be a nightmare of editing the .vmt file.
I'll do my best to explain what each does.

That's a lot of info to take in. We're going to adapt this to our lava texture we made earlier. We won't be needing the refracting parts of the texture, and simply need water physics and water fog.
It'll look something like this:
Now that that's complete, we're going to copy and paste this into our .vmt file and boot it up in game. The underwater part of our lava texture looks like this:


The thing is, this isn't really a water texture. Yes, source does consider it water, but it simply uses the water properties. To make it truly water, we would have to use the "Water" shader parameter. This will change the effect to something way more realistic. Textures using the "Water" shader don't need a $basetexture if it's an orange box game or older. We're simply going to change our "LightmappedGeneric" to "Water" to change how it looks in game. This will add the realistic wave effect.

A mirror is essentially a super-reflective texture. They are put on func_reflective_glass entities in hammer.
Here is what our .vmt parameters would look like:

What we're essentially doing here is making our regular texture use the refract and reflect water parameters. This creates the mirror effect we want. We could also change the tint parameters to change the colors reflected if we really wanted to. Our texture in game looks like this:



Note: the texture will appear as a missing texture in the level editor in hammer. The texture will properly load ingame.
Note: don't stack 2 mirrors where they see each other. You'll be unable to compile your map.

Since no one has ever made any remarks about custom monitor textures, I'll take the step forward and figure it out. Here's a scan line image I'll be using for this:


To start, we're going to make this a .vtf file. Then we're going to make one hell of a .vmt file. The first thing we MUST add to our texture is:

This tells source that our texture is compatible with the func_monitor entity (meaning that it doesn't produce a missing texture when used). We also don't need to the "$texture2" parameter, if we just wanted our camera without any sort of overlay. Same goes for "%tooltexture", but that's just to help us know if it's a monitor texture in hammer.

Our full texture should look something like this:

This is simply some parameters pasted over from other monitor textures in source. The "Sine" proxy adds the wave effect you sometimes see on monitors. Most monitor textures in source use the same texture, but have variations due to the .vmt parameters. Our monitor texture in game looks like this:


(Notice how Gmod makes a mess out of the camera angles, but the texture does work.)

A list of some parameters you can put in a .vmt file. A full list an be found Here.

"LightmappedGeneric"

"$basetexture" "TEXTURE_NAME"
// This is the name of your texture

"$surfacetexture" "Watermelon"
// This is the surface texture, which defines stuff as what bullet decals look like and surface properties

"$translucent" 1
// This means it will use the alpha channel (transparency) of the texture

"$basetexture2" "TEXTURE_NAME2"
"$surfacetexture2" "Concrete"
// These are used with blend textures to define the other material's parameters

"$decal" 1
"$decalscale" 0.25
// This means that the texture is a decal, decal scale is the scale of the texture

"$nodecal" 1
// This makes your texture not show bullet decals when shot

"$alpha" 0.5
// Makes your texture have a defined alpha (transparency), which is useful for glass textures. Can only be a value between 0 and 1

"$envmap" "env_cubemap"
// This means that the texture will use reflections created by cubemaps

"$bumpmap" "TEXTURE_NAME_normal"
// This means it will use the normal map of a texture. The name of the normal can be anything, but is usually the name of the texture follow by _normal

"%compilepassbullets" 1
// This will make it so bullets go through the texture

"%notooltexture" 1
// This will make your texture not able to be found in the hammer texture browser

"%keywords" "KEYWORD"
// This will use the keyword function in the hammer texture browser

"Proxies"
// This will enable Proxies to be used on the texture (stuff like animated textures)


"TextureScroll"
{
"Texturescrollvar" "$Basetexturetransform"
"Texturescrollrate" 2
"texturescrollangle" 90
}
// This will make your texture scrolling, texturescrollrate changes how fast the texture scrolls, texturescrollangle changes the direction it scrolls (90 is sideways)

"AnimatedTexture"
{
"animatedTextureVar" "$basetexture"
"animatedTextureFrameNumVar" "$frame"
"animatedTextureFrameRate" 2
}
// This will make your texture animated, animatedTextureFrameRate changes how fast it changes between frames (2 is default)

Shader types are essentially the first line in your .vmt file.

That was an example of a shader you can use for your textures. There are many different types of shaders, all of which can be found here if you're really curious.
I've created a table of most shader parameters you'll use and what they do. This also covers some more abstract texture shaders.


Essentially, DX values are used on PCs with lower specs, to improve performance. It'll only be activated when

Since there are actually a metric ton of proxies that exist (excpet most of them are just used for very specific circumstances), I'm just going to leave a link here, so you can explore on your own time.

These are all the webistes and articles I used to help me make this guide. If you think the guide didn't explain certain elements very well, you can use the sources below for more help:

• Texture Parameters
  
• Water .vmt file explained
  
• Blend Textures[gamebanana.com]
  
• A list of all material proxies
  
• 2D Skybox creation
  
• Parallax mapping (form of bump mapping)
  
• Textures for models
  
• Dynamic materials with proxies[www.nodraw.net]

If you want to download all the .png, .vtf and .vmt files I used in this tutorial, you can download it here with dropbox.[www.dropbox.com] To use them properly, extract the files from the .zip, and put them in your game's "materials" folder.

If you enjoyed the guide and want to support me, you can positively rate this guide.

If you have any suggestions / questions, you can post them in the comment section. I'll try to read them or answer them as fast as I can.