Difference between revisions of "Shader"

From Valve Developer Community
Jump to: navigation, search
m (Introduction)
m (Convert {{otherlang2}} to {{lang}}.)
 
(27 intermediate revisions by 19 users not shown)
Line 1: Line 1:
==Introduction==
+
{{lang|Shader}}
  
A shader is a program that runs on the graphics hardware (GPU) rather than the CPU. There are two variations of shaders, Pixel shaders and Vertex shaders, each of which performs a different task in the rendering pipeline. Shaders form a replacement for the fixed function pipeline and allow developers greater control over rendering output by providing the ability to modify pixels and vertices dynamically.
+
A '''shader''' is software which runs on a [[Wikipedia:Graphics processing unit|graphics card]] to  determine how an object should be drawn. Source uses shaders for everything in the 3D world.
  
There are currently three main shader languages, [[HLSL]], [[CG]] and [http://en.wikipedia.org/wiki/GLSL GLSL]. The [[Source Engine]] uses [[HLSL]] based shaders, however [[CG]] is so similar that most [[CG]] shaders can be quickly and easily ported to [[HLSL]].
+
Shaders are manipulated with parameters stored in [[material]] files. While the most common are quite simple, very complex ones exist to handle effects like real-time shadowing, lighting and refraction.
  
There are a variety of different models of the shader system; 1.1, 1.4, 2.0 and 3.0. Shader Model (SM) 3.0 is only available on high end graphics cards such as the nVidia 6x00 and 7x00 series of cards, or the ATI X1x00 and Xx00 series of cards.
+
==Types==
  
The most common Shader Model version is 2.0 of which there are three different versions:  
+
There are two variations of shaders, Pixel shaders and Vertex shaders, each of which performs a different task in the rendering pipeline. Shaders form a replacement for the fixed function pipeline and allow developers greater control over rendering output by providing the ability to modify pixels and vertices dynamically. The SDK includes many [[:Category:Shaders|existing shaders]].
  
* PS_2_0, which is the standard PS2.0 version and has a limit of 32 Texture instructions;
+
== Shader languages ==
* PS_2_a, which is the nVidia GeForce FX optimized model;
+
There are currently three main shader languages: [[HLSL|High Level Shader Language (HLSL)]], [[CG|C for Graphics (Cg)]] and [[Wikipedia:GLSL | OpenGL Shading Language (GLSL)]]. The Source engine uses [[HLSL]] based shaders. However Cg is so similar that most Cg shaders can be quickly and easily ported to HLSL.
* PS_2_b, the ATI X700/X800/X850 and DirectX 9.0b Shader Model.
 
  
Most of the time, however, SM2.0 is generalized, so no specific target needs to be specified when compiling.
+
== Shader models ==
It is important to pay attention to the shader model being compiled with when creating shaders as older graphics cards that only support SM 1.4 will not run shaders created using SM 2.0. In this case, shader fallbacks must be specified to provide some form of support for users with slightly outdated hardware.
+
A shader model defines how ''advanced'' shading techniques are allowed to get on a graphics card. This prevents older graphics cards from being physically able to recognize newer shading techniques.
  
For information on authoring shaders for use in the [[Source Engine]], please see [[Shader Authoring]].
+
Modern versions of [[Source]] support Shader Model 2.0 (including Pixel Shader 2.0b) and Shader Model 3.0.
 +
{{Note|Shaders written for SM3 may not work properly on Mac and Linux systems due to lack of support in Valve's runtime graphics wrapper, <code>togl</code>. You should plan to make a SM2.0b version of your shaders if you plan on supporting these systems.}}
  
===Vertex Shaders===
+
When creating shaders for newer graphics cards, it's important to remember to support those with older cards, or you will quickly limit the specs of your game to only a select few. Older cards can require so called "shader fallbacks" to be specified, where a backup shader (using an older shader model) will be used if the newer shader fails.
Vertex shaders are applied for each vertex run on a programmable pipeline. Its most basic goal is to transform geometry into screenspace coordinates so that the Pixel shader can rasterize an image. On a more complex scale, Vertex shaders are responsible for mesh deformation, lighting, shadowing and general vertex displacement. Vertex shaders cannot create vertices.
+
 
 +
If you want to learn more about the detailed specs of different Shader Models, read the [[Wikipedia:High Level Shader Language|Wikipedia article]].
 +
 
 +
For information on authoring shaders for use in the Source engine, please see [[Shader Authoring]].
 +
 
 +
== Vertex shaders ==
 +
Vertex shaders are applied for each vertex run on a programmable pipeline. Its most basic goal is to transform geometry into screenspace coordinates so that the Pixel shader can rasterize an image. Vertex shaders can modify these position coordinates to perform mesh deformation. They can also receive additional information from the mesh, including normals, tangents, and texture coordinates. The vertex shader then writes to output registers; the written values are then interpolated across the vertices in the pixel shaders. Vertex shaders cannot create vertices.
  
 
A heavily commented example vertex shader, ready for use in Source is provided below.
 
A heavily commented example vertex shader, ready for use in Source is provided below.
  
====Example Vertex Shader====
+
=== Example vertex shader ===
 
 
 
This is a pass through shader - in so far as it makes no major modification to the vertex data, instead just passing the data through to the pixel shader stage.
 
This is a pass through shader - in so far as it makes no major modification to the vertex data, instead just passing the data through to the pixel shader stage.
  
Line 53: Line 58:
 
  }
 
  }
  
===Pixel Shaders===
+
== Pixel shaders ==
Pixel shaders are applied for each pixel rendered to the screen. A pixel shader expects input from interpolated vertex values, which it then uses to rasterize the image. Pixel shaders can produce a huge range of effects involving the colour of individual pixels such as refraction, per-pixel lighting or reflection.
+
Pixel shaders are applied for each pixel rendered to the screen. A pixel shader expects input from interpolated vertex values, which it then uses to rasterize the image. Pixel shaders can produce a huge range of effects involving the color of individual pixels such as refraction, per-pixel lighting or reflection.
  
 
A heavily commented example pixel shader, ready for use in Source is provided below.
 
A heavily commented example pixel shader, ready for use in Source is provided below.
  
====Example Pixel Shader====
+
=== Example pixel shader ===
 
 
 
The pixel shader below is intended for use as a post-process shader and creates a grayscale effect.
 
The pixel shader below is intended for use as a post-process shader and creates a grayscale effect.
  
Line 78: Line 82:
 
  }
 
  }
  
==Applications of Shaders in Source==
+
== Applications of shaders in Source ==
 
+
The Source engine provides for two separate forms of shaders, Postprocess and Per-Object, the majority of the effects and materials used within the Source engine rely heavily on their Pixel shader components.
The [[Source Engine]] provides for two separate forms of shaders, Postprocess and Per-Object, the majority of the effects and materials used within the [[Source Engine]] rely heavily on their Pixel shader components.
 
  
===Postprocess===
+
=== Postprocess ===
 +
A Postprocess shader is typically a Pixel shader that works on a quad rendered across the entire screen. The quad is textured with a copy of the frame buffer, the Pixel shader can then alter and modify the rendered output to create a variety of effects, such as basic color modification to more advanced processes such as motion blur and bloom.
  
A Postprocess shader is typically a Pixel shader that works on a quad rendered across the entire screen. The quad is textured with a copy of the frame buffer, the Pixel shader can than alter and modify the rendered output to create a variety of effects, such as basic colour modification to more advanced processes such as motion blur and bloom.
+
{{Note| This information is out of date, and the files are no longer included in the SDK.  <code>sdk_bloom.cpp</code> and <code>sdk_bloom.ps20.fxc</code> define one possible shader that could be used as an alternative example}}
 +
The Source SDK provides an example of this form of shader in the postprocess files (<code>sdk_postprocess.cpp</code>, <code>sdk_postprocess_vs20.fxc</code>, and <code>sdk_postprocess_ps20.fxc</code>)
  
The Source SDK provides an example of this form of shader in the sdk_postprocess files (<code>sdk_postprocess.cpp</code>, <code>sdk_postprocess_vs20.fxc</code>, and <code>sdk_postprocess_ps20.fxc</code>)
+
Advanced Postprocess shaders, such as the bloom and motion blur shaders included with source, may also need to use custom [[Render Targets]]. For more information on integrating a Postprocess shader with a mod, see [[Custom_Postprocessing_Effects]]
  
===Per-Object===
+
=== Per-object ===
 +
A Per-Object shader in the Source engine is used on any object with the shader referenced in the relevant [[VMT|Valve Material (.vmt)]] file, such as a model or piece of brushwork. A Per-Object shader could be used to create a refractive material, modify a models vertices dynamically or other advanced rendering effects.
  
A Per-Object shader in the [[Source Engine]] is used on any object with the shader referenced in the relevant [[VMT]] file, such as a model or piece of brushwork. A Per-Object shader could be used to create a refractive material, modify a models vertices dynamically or other advanced rendering effects.
+
The Source SDK provides an example of a Per-Object shader in the lightmap files ( <code>sdk_lightmap.cpp</code>, <code>sdk_lightmap_vs20.fxc</code>, and <code>sdk_lightmap_ps20.fxc</code>)
  
The Source SDK provides an example of a Per-Object shader in the sdk_lightmap files ( <code>sdk_lightmap.cpp</code>, <code>sdk_lightmap_vs20.fxc</code>, and <code>sdk_lightmap_ps20.fxc</code>)
+
== External links ==
 +
* [http://www.bit-tech.net/hardware/2005/07/25/guide_to_shaders/1 A bluffer's guide to Shader Models]
 +
* [http://http.developer.nvidia.com/CgTutorial/cg_tutorial_chapter01.html NVIDIA - The Cg tutorial]
 +
* [https://developer.nvidia.com/gpugems/GPUGems/gpugems_part01.html NVIDIA - GPU Gems]
 +
* [https://developer.nvidia.com/gpugems/GPUGems2/gpugems2_part01.html NVIDIA - GPU Gems 2]
 +
* [https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_part01.html NVIDIA - GPU Gems 3]
 +
* {{wiki|Shader}} - a Wikipedia article on the subject.
 +
* [http://www.moddb.com/games/half-life-2/tutorials/introduction-to-shaders Introduction to Shaders Tutorial from Wraiyth]
 +
* [http://www.moddb.com/games/half-life-2/tutorials/post-process-shader Post-Process Shader Tutorial from Wraiyth]
  
==Further Reading==
 
* [[Wikipedia:Shader]]
 
* [http://developer.nvidia.com/object/gpu_gems_home.html GPU Gems]
 
* [http://developer.nvidia.com/object/gpu_gems_2_home.html GPU Gems 2]
 
* [http://developer.nvidia.com/object/cg_tutorial_home.html The CG tutorial]
 
* [http://wraiyth.freesuperhost.com/development/tutorials/postprocess.htm Simple Post-Process Shader tutorial]
 
* [http://wraiyth.freesuperhost.com/development/tutorials/nvidiaconvert.htm Converting nVidia SDK shaders to HL2 (sample)]
 
  
[[category:Programming]] [[category:Glossary]] [[category:Technical]]
+
[[Category: Glossary]]
 +
[[Category: Programming]]
 +
[[Category: Shaders|*]]
 +
[[Category: Technical]]

Latest revision as of 15:57, 2 September 2021

English Русский

A shader is software which runs on a graphics card to determine how an object should be drawn. Source uses shaders for everything in the 3D world.

Shaders are manipulated with parameters stored in material files. While the most common are quite simple, very complex ones exist to handle effects like real-time shadowing, lighting and refraction.

Types

There are two variations of shaders, Pixel shaders and Vertex shaders, each of which performs a different task in the rendering pipeline. Shaders form a replacement for the fixed function pipeline and allow developers greater control over rendering output by providing the ability to modify pixels and vertices dynamically. The SDK includes many existing shaders.

Shader languages

There are currently three main shader languages: High Level Shader Language (HLSL), C for Graphics (Cg) and OpenGL Shading Language (GLSL). The Source engine uses HLSL based shaders. However Cg is so similar that most Cg shaders can be quickly and easily ported to HLSL.

Shader models

A shader model defines how advanced shading techniques are allowed to get on a graphics card. This prevents older graphics cards from being physically able to recognize newer shading techniques.

Modern versions of Source support Shader Model 2.0 (including Pixel Shader 2.0b) and Shader Model 3.0.

Note.png Note: Shaders written for SM3 may not work properly on Mac and Linux systems due to lack of support in Valve's runtime graphics wrapper, togl. You should plan to make a SM2.0b version of your shaders if you plan on supporting these systems.

When creating shaders for newer graphics cards, it's important to remember to support those with older cards, or you will quickly limit the specs of your game to only a select few. Older cards can require so called "shader fallbacks" to be specified, where a backup shader (using an older shader model) will be used if the newer shader fails.

If you want to learn more about the detailed specs of different Shader Models, read the Wikipedia article.

For information on authoring shaders for use in the Source engine, please see Shader Authoring.

Vertex shaders

Vertex shaders are applied for each vertex run on a programmable pipeline. Its most basic goal is to transform geometry into screenspace coordinates so that the Pixel shader can rasterize an image. Vertex shaders can modify these position coordinates to perform mesh deformation. They can also receive additional information from the mesh, including normals, tangents, and texture coordinates. The vertex shader then writes to output registers; the written values are then interpolated across the vertices in the pixel shaders. Vertex shaders cannot create vertices.

A heavily commented example vertex shader, ready for use in Source is provided below.

Example vertex shader

This is a pass through shader - in so far as it makes no major modification to the vertex data, instead just passing the data through to the pixel shader stage.

// common vertex shader defines provided with this header
#include "common_vs_fxc.h"
// define an output structure struct VS_OUTPUT { // position vector (float4) float4 pos  : POSITION0; // texture coordinates (uv - float2) float2 texCoord  : TEXCOORD0; };
// main function - note C style definition // takes a position vector (float4) // returns a VS_OUTPUT struct VS_OUTPUT main( float4 inPos: POSITION ) { // declare an empty VS_OUTPUT to fill VS_OUTPUT o = (VS_OUTPUT) 0;
// compute the sign of the input position inPos.xy = sign( inPos.xy); // set the output position using the xy of the input o.pos = float4( inPos.xy, 0.0f, 1.0f);
// get into range [0,1] o.texCoord = (float2(o.pos.x, -o.pos.y) + 1.0f)/2.0f; return o; }

Pixel shaders

Pixel shaders are applied for each pixel rendered to the screen. A pixel shader expects input from interpolated vertex values, which it then uses to rasterize the image. Pixel shaders can produce a huge range of effects involving the color of individual pixels such as refraction, per-pixel lighting or reflection.

A heavily commented example pixel shader, ready for use in Source is provided below.

Example pixel shader

The pixel shader below is intended for use as a post-process shader and creates a grayscale effect.

// specify a texture sampler, the actual source of this is specified in a vmt
sampler2D Texture0 : register( s0 );
// same function declaration style as vertex shaders // pixel shaders return the colour value of the pixel (hence the float4) float4 main( float2 texCoord  : TEXCOORD0 ) : COLOR { // sample the texture at the specified texture coordinates float4 tex = tex2D( Texture0, texCoord );
// greyscale the pixel colour values // - perform a dot product between the pixel colour and the specified vector // - 0.222, 0.707, 0.071 is found throughout image processing for gray scale effects. float4 grey = dot(float3(0.222, 0.707, 0.071), tex);
// return the pixel colour in the form of a float4. return grey; }

Applications of shaders in Source

The Source engine provides for two separate forms of shaders, Postprocess and Per-Object, the majority of the effects and materials used within the Source engine rely heavily on their Pixel shader components.

Postprocess

A Postprocess shader is typically a Pixel shader that works on a quad rendered across the entire screen. The quad is textured with a copy of the frame buffer, the Pixel shader can then alter and modify the rendered output to create a variety of effects, such as basic color modification to more advanced processes such as motion blur and bloom.

Note.png Note:  This information is out of date, and the files are no longer included in the SDK. sdk_bloom.cpp and sdk_bloom.ps20.fxc define one possible shader that could be used as an alternative example

The Source SDK provides an example of this form of shader in the postprocess files (sdk_postprocess.cpp, sdk_postprocess_vs20.fxc, and sdk_postprocess_ps20.fxc)

Advanced Postprocess shaders, such as the bloom and motion blur shaders included with source, may also need to use custom Render Targets. For more information on integrating a Postprocess shader with a mod, see Custom_Postprocessing_Effects

Per-object

A Per-Object shader in the Source engine is used on any object with the shader referenced in the relevant Valve Material (.vmt) file, such as a model or piece of brushwork. A Per-Object shader could be used to create a refractive material, modify a models vertices dynamically or other advanced rendering effects.

The Source SDK provides an example of a Per-Object shader in the lightmap files ( sdk_lightmap.cpp, sdk_lightmap_vs20.fxc, and sdk_lightmap_ps20.fxc)

External links