 | This articlerelies excessively onreferences toprimary sources. Please improve this article by addingsecondary or tertiary sources. Find sources: "Cg" programming language – news ·newspapers ·books ·scholar ·JSTOR(May 2024) (Learn how and when to remove this message) |
| Cg/HLSL | |
|---|---|
 A scene containing several different 2D HLSL shaders.Distortion of the statue is achieved purely physically, while the texture of the rectangular frame beside it is based on color intensity. The square in the background has beentransformed androtated. The partialtransparency andreflection of the water in the foreground are added by a shader applied finally to the entire scene. | |
| Family | shading language |
| Developer | nVIDIA, Microsoft |
| Website | developer |
| Dialects | |
| Cg, HLSL, Playstation Shading Language | |
| Influenced by | |
| C,RenderMan Shading Language | |
| Influenced | |
| GLSL | |
Cg (short forC for Graphics), also known asHigh-Level Shader Language (HLSL), is a high-levelshading language developed byNvidia andMicrosoft for programmingshaders. Cg/HLSL is based on theC programming language and although they share the same core syntax, some features of C were modified and new data types were added to make Cg/HLSL more suitable for programminggraphics processing units.[1][2]
Two main branches of the Cg/HLSL language exist: the Nvidia Cg compiler (cgc) which outputsDirectX orOpenGL and the Microsoft HLSL which outputs DirectX shaders in bytecode format.[3][4] Nvidia's cgc wasdeprecated in 2012, with no additional development or support available.[5]
HLSL shaders can enable manyspecial effects in both 2D and 3Dcomputer graphics. The Cg/HLSL language originally only included support forvertex shaders andpixel shaders, but other types of shaders were introduced gradually as well:
Due to technical advances in graphics hardware, some areas of 3D graphics programming have become quite complex. To simplify the process, new features were added to graphics cards, including the ability to modify their rendering pipelines using vertex and pixel shaders.
In the beginning, vertex and pixel shaders were programmed at a very low level with only the assembly language of the graphics processing unit. Although using the assembly language gave the programmer complete control over code and flexibility, it was fairly hard to use. A portable, higher level language for programming the GPU was needed, so Cg was created to overcome these problems and make shader development easier.
Some of the benefits of using Cg over assembly are:
Cg has six basic data types. Some of them are the same as in C, while others are especially added for GPU programming. These types are:
Cg also features vector and matrix data types that are based on the basic data types, such as float3 and float4x4. Such data types are quite common when dealing with 3D graphics programming. Cg also has struct andarray data types, which work in a similar way to their C equivalents.
Cg supports a wide range of operators, including the common arithmetic operators from C, the equivalent arithmetic operators for vector and matrix data types, and the commonlogical operators.
Cg shares the basic control structures with C, like if/else, while, and for. It also has a similar way of defining functions.
Cg implements manyC preprocessor directives and its macro expansion system. It implements#include.[7]
Cg programs are built for differentshader profiles that stand for GPUs with different capabilities.[8] These profiles decide, among others, how many instructions can be in each shader, how many registers are available, and what kind of resources a shader can use. Even if a program is correct, it might be too complex to work on a profile.[7]
As the number of profile and shader types cropped up, Microsoft has switched to use the term "Shader Model" to group a set of profiles found in a generation of GPUs.[9] Cg supports some of the newer profiles up to Shader Model 5.0 as well as translation to glsl or hlsl.[8]
| Pixel shader version | 1.0 to 1.3[10] | 1.4[10] | 2.0[10][11] | 2.0a[10][11][12] | 2.0b[10][11][13] | 3.0[10][14] | 4.0[15] 4.1[16] 5.0[17] |
|---|---|---|---|---|---|---|---|
| Dependent texture limit | 4 | 6 | 8 | Unlimited | 8 | Unlimited | Unlimited |
| Texture instruction limit | 4 | 6*2 | 32 | Unlimited | Unlimited | Unlimited | Unlimited |
| Position register | No | No | No | No | No | Yes | Yes |
| Instruction slots | 8+4 | 8+4 | 32 + 64 | 512 | 512 | ≥ 512 | ≥ 65536 |
| Executed instructions | 8+4 | 6*2+8*2 | 32 + 64 | 512 | 512 | 65536 | Unlimited |
| Texture indirections | 4 | 4 | 4 | Unlimited | 4 | Unlimited | Unlimited |
| Interpolated registers | 2 + 4 | 2 + 6 | 2 + 8 | 2 + 8 | 2 + 8 | 10 | 32 |
| Instruction predication | No | No | No | Yes | No | Yes | No |
| Index input registers | No | No | No | No | No | Yes | Yes |
| Temp registers | 2 | 6 | 12 to 32 | 22 | 32 | 32 | 4096 |
| Constant registers | 8 | 8 | 32 | 32 | 32 | 224 | 16×4096 |
| Arbitraryswizzling | No | No | No | Yes | No | Yes | Yes |
| Gradient instructions | No | No | No | Yes | No | Yes | Yes |
| Loop count register | No | No | No | No | No | Yes | Yes |
| Face register (2-sided lighting) | No | No | No | No | Yes | Yes | Yes |
| Dynamic flow control | No | No | No | No | No | Yes (24) | Yes (64) |
| Bitwise Operators | No | No | No | No | No | No | Yes |
| Native Integers | No | No | No | No | No | No | Yes |
"32 + 64" forExecuted Instructions means "32 texture instructions and 64 arithmetic instructions."
| Vertex shader version | VS 1.1[18] | VS 2.0[11][18][19] | VS 2.0a[11][18][19] | VS 3.0[14][18] | VS 4.0[15] VS 4.1[20] VS 5.0[17] |
|---|---|---|---|---|---|
| # of instruction slots | 128 | 256 | 256 | ≥ 512 | ≥ 65536 |
| Max # of instructions executed | 128 | 1024 | 65536 | 65536 | Unlimited |
| Instruction predication | No | No | Yes | Yes | Yes |
| Temp registers | 12 | 12 | 16 | 32 | 4096 |
| # constant registers | ≥ 96 | ≥ 256 | 256 | ≥ 256 | 16×4096 |
| Static flow control | No | Yes | Yes | Yes | Yes |
| Dynamic flow control | No | No | Yes | Yes | Yes |
| Dynamic flow control depth | — | — | 24 | 24 | 64 |
| Vertex texture fetch | No | No | No | Yes | Yes |
| # of texture samplers | — | — | — | 4 | 128 |
| Geometry instancing support | No | No | No | Yes | Yes |
| Bitwise operators | No | No | No | No | Yes |
| Native integers | No | No | No | No | Yes |
As in C, Cg/HLSL features a set of functions for common tasks in GPU programming. Some of the functions have equivalents in C, like the mathematical functions abs and sin, while others are specialized in GPU programming tasks, like thetexture mapping functions tex1D and tex2D.
Cg programs are merely vertex and pixel shaders, and they need supporting programs that handle the rest of the rendering process. Cg can be used with two graphicsAPIs:OpenGL orDirectX. Each has its own set of Cg functions to communicate with the Cg program, like setting the current Cg shader, passing parameters, and such tasks.
In addition to being able to compile Cg source to assembly code, the Cg runtime also has the ability to compile shaders during execution of the supporting program. This allows the runtime to compile the shader using the latest optimizations available for hardware that the program is currently executing on. However, this technique requires that the source code for the shader be available in plain text to the compiler, allowing the user of the program to access the source-code for the shader. Some developers view this as a major drawback of this technique.
To avoid exposing the source code of the shader, and still maintain some of the hardware specific optimizations, the concept of profiles was developed. Shaders can be compiled to suit different graphics hardware platforms (according to profiles). When executing the supporting program, the best/most optimized shader is loaded according to its profile. For instance there might be a profile for a graphics card that supports complex pixel shaders, and another profile for one that supports only minimal pixel shaders. By creating a pixel shader for each of these profiles a supporting program enlarges the number of supported hardware platforms without sacrificing picture quality on powerful systems.'
The Cg dialect has only ever had one compiler, in the form of Nvidia's Cg toolkit.
Microsoft has released two compilers for HLSL. The original compiler was the closed-source FXC (Effect Compiler), supported until 2015. It was deprecated in favor of the open-sourceLLVM-based DXC (DirectXShaderCompiler) with support for newer HLSL features.[21] Both compilers generate bytecode: while the older FXC used DXBC, DXC now uses DXIL. DXC can also emitSPIR-V bytecode.[22]
TheKhronos Group has also written a LLVM-based HLSL compiler, in the form of a frontend forglslang, their GLSL-to-SPIR_V compiler. Support for SPIR-V means that the shaders can be cross-platform, no longer limiting them to a DirectX stack.[23] This task was previously performed by source-level converters likeHLSL2GLSL, but the resulting code is often bloated.[24]
ThePlayStation Shader Language (PSSL) is based on Cg/HLSL.[25]
The ReshadeFX shading language is also based on Cg/HLSL. Shaders written in ReshadeFX are compiled to OpenGL, DX, or Vulkan and injected into games to act as post-processing filters.[26]