Cg (programming language): Difference between revisions
Artoria2e5 (talk | contribs) |
|||
(28 intermediate revisions by 24 users not shown) | |||
Line 1: | Line 1: | ||
{{short description|Shading language}} |
{{short description|Shading language}}{{Primary sources|date=May 2024}}{{Infobox programming language |
||
{{Infobox programming language |
|||
| name = Cg/HLSL |
| name = Cg/HLSL |
||
| logo = <!-- (filename) --> |
| logo = <!-- (filename) --> |
||
Line 11: | Line 10: | ||
| developer = nVIDIA, Microsoft |
| developer = nVIDIA, Microsoft |
||
| dialects = Cg, HLSL, Playstation Shading Language |
| dialects = Cg, HLSL, Playstation Shading Language |
||
| influenced by = [[C]], [[RenderMan |
| influenced by = [[C (programming language)|C]], [[RenderMan Shading Language]] |
||
| influenced = [[GLSL]] |
| influenced = [[GLSL]] |
||
}} |
}} |
||
<!--{{Merge|High-Level |
<!--{{Merge|High-Level Shader Language|discuss=Talk:High-Level Shader Language#Proposed merge of Cg (programming language) with High-Level Shading Language|date=April 2020}}--> |
||
'''Cg''' (short for '''C for Graphics''') and |
'''Cg''' (short for '''C for Graphics''') and [[High-Level Shader Language]] (HLSL) are two names given to a high-level [[shading language]] developed by [[Nvidia]] and [[Microsoft]] for [[computer programming|programming]] [[shader]]s. Cg/HLSL is based on the [[C (programming language)|C 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 programming [[graphics processing unit]]s.<ref>{{cite web|url=http://www.fusionindustries.com/default.asp?page=cg-hlsl-faq|archive-url=https://web.archive.org/web/20120824051248/http://www.fusionindustries.com/default.asp?page=cg-hlsl-faq|url-status=dead|archive-date=24 August 2012|title=Fusion Industries :: Cg and HLSL FAQ ::|date=24 August 2012}}</ref><ref>{{cite web |title=The Cg Tutorial - Chapter 1. Introduction |url=https://developer.download.nvidia.cn/CgTutorial/cg_tutorial_chapter01.html |website=developer.download.nvidia.cn}}</ref> |
||
Two main branches of the Cg/HLSL language exist: the Nvidia Cg compiler (cgc) which outputs [[DirectX]] or [[OpenGL]] and the Microsoft HLSL which outputs DirectX shaders in bytecode format.<ref>{{cite web|url=https://msdn.microsoft.com/en-us/library/windows/desktop/bb944006.aspx|title=Writing HLSL Shaders in Direct3D 9 (Windows)|website=msdn.microsoft.com}}</ref><ref>{{cite web|title=Cg FAQ|url=https://developer.nvidia.com/cg-faq|website=NVIDIA DesignWorks|date=8 March 2011| |
Two main branches of the Cg/HLSL language exist: the Nvidia Cg compiler (cgc) which outputs [[DirectX]] or [[OpenGL]] and the Microsoft HLSL which outputs DirectX shaders in bytecode format.<ref>{{cite web|url=https://msdn.microsoft.com/en-us/library/windows/desktop/bb944006.aspx|title=Writing HLSL Shaders in Direct3D 9 (Windows)|website=msdn.microsoft.com|date=24 May 2021 }}</ref><ref>{{cite web|title=Cg FAQ|url=https://developer.nvidia.com/cg-faq|website=NVIDIA DesignWorks|date=8 March 2011|access-date=25 May 2017}}</ref> Nvidia's cgc was [[Deprecation|deprecated]] in 2012, with no additional development or support available.<ref>{{cite web|url=https://developer.nvidia.com/cg-toolkit|title=Cg Toolkit | NVIDIA Developer|date=8 March 2011}}</ref> |
||
HLSL shaders can enable |
HLSL shaders can enable many [[special effects]] in both 2D and 3D [[computer graphics]]. The Cg/HLSL language originally only included support for [[vertex shader]]s and [[pixel shader]]s, but other types of shaders were introduced gradually as well: |
||
* DirectX 10 (Shader Model 4) and Cg 2.0 introduced [[geometry shader]]s.<ref>https://developer.download.nvidia.com/cg/Cg_2.0/2.0.0012/Cg-2.0_Jan2008_ReleaseNotes.pdf</ref> |
* DirectX 10 (Shader Model 4) and Cg 2.0 introduced [[geometry shader]]s.<ref>{{Cite web |date=January 2008 |title=Cg 2.0 Release Notes |url=https://developer.download.nvidia.com/cg/Cg_2.0/2.0.0012/Cg-2.0_Jan2008_ReleaseNotes.pdf |website=nvidia.com}}</ref> |
||
* DirectX 11 (Shader Model 5) introduced [[compute shader]]s ([[GPGPU]]) and [[tessellation shader]]s (hull and domain). The latter is present in Cg 3.1. |
* DirectX 11 (Shader Model 5) introduced [[compute shader]]s ([[GPGPU]]) and [[tessellation shader]]s (hull and domain). The latter is present in Cg 3.1. |
||
* DirectX 12 (Shader Model 6.3) introduced [[Ray tracing (graphics)|ray tracing]] shaders (ray generation, intersection, bit /closest hit / miss). |
* DirectX 12 (Shader Model 6.3) introduced [[Ray tracing (graphics)|ray tracing]] shaders (ray generation, intersection, bit / closest hit / miss). |
||
==Background== |
==Background== |
||
Line 59: | Line 58: | ||
=== Preprocessor === |
=== Preprocessor === |
||
Cg implements many [[C preprocessor]] directives and its macro expansion system. It implements {{code|#include}}.<ref name=2p>[[Mark Kilgard|Mark J. Kilgard]], [https://arxiv.org/abs/cs/0302013 ''Cg in Two Pages''], 2003.</ref> |
Cg implements many [[C preprocessor]] directives and its macro expansion system. It implements {{code|#include}}.<ref name=2p>[[Mark Kilgard|Mark J. Kilgard]], [https://arxiv.org/abs/cs/0302013 ''Cg in Two Pages''], 2003.</ref> |
||
=== HLSL features === |
|||
* Namespace |
|||
* Annotation |
|||
== Environment == |
== Environment == |
||
Line 65: | Line 68: | ||
Cg programs are built for different ''shader profiles'' that stand for GPUs with different capabilities.<ref name=cgp>{{cite web |title=Cg Profile Documentation |url=http://developer.download.nvidia.com/cg/index_profiles.html |website=Nvidia developer}}</ref> 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.<ref name=2p/> |
Cg programs are built for different ''shader profiles'' that stand for GPUs with different capabilities.<ref name=cgp>{{cite web |title=Cg Profile Documentation |url=http://developer.download.nvidia.com/cg/index_profiles.html |website=Nvidia developer}}</ref> 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.<ref name=2p/> |
||
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.<ref>{{cite web |title=Shader Models vs Shader Profiles - Win32 apps |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-models |website=docs.microsoft.com |language=en-us}}</ref> Cg supports some of the newer profiles up to Shader Model 5.0 as well as translation to glsl or hlsl.<ref name=cgp/> |
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.<ref>{{cite web |title=Shader Models vs Shader Profiles - Win32 apps |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-models |website=docs.microsoft.com |date=30 June 2021 |language=en-us}}</ref> Cg supports some of the newer profiles up to Shader Model 5.0 as well as translation to glsl or hlsl.<ref name=cgp/> |
||
{| class="wikitable" |
{| class="wikitable" |
||
|+Comparison of HLSL pixel shaders |
|+Comparison of HLSL pixel shaders |
||
! Pixel shader version |
! Pixel shader version |
||
!1.0 to 1.3<ref name="PS1-3">{{cite web|url=https://msdn.microsoft.com/en-us/library/bb219846(v=VS.85).aspx|title=Pixel Shader Differences|date=2011-02-08|work=msdn.microsoft.com}}</ref> |
!1.0 to 1.3<ref name="PS1-3">{{cite web|url=https://msdn.microsoft.com/en-us/library/bb219846(v=VS.85).aspx|title=Pixel Shader Differences|date=2011-02-08|work=msdn.microsoft.com}}</ref> |
||
!1.4<ref name="PS1-3"/> !!2.0<ref name="PS1-3"/><ref name=SM2>{{cite web|url=http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=18901|title=Microsoft DirectX High Level Shader Language (HLSL)|first=Craig|last=Peeper|format=PPT|pages=5–8, 24–25|date=2004-03-15|work=microsoft.com}}</ref> !!2.0a<ref name="PS1-3"/><ref name=SM2/><ref>{{cite web|url=http://anandtech.com/show/1034/4|title=NVIDIA Introduces GeForce FX (NV30)|first=Anand Lal|last=Shimpi |
!1.4<ref name="PS1-3"/> !!2.0<ref name="PS1-3"/><ref name=SM2>{{cite web|url=http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=18901|title=Microsoft DirectX High Level Shader Language (HLSL)|first=Craig|last=Peeper|format=PPT|pages=5–8, 24–25|date=2004-03-15|work=microsoft.com}}</ref> !!2.0a<ref name="PS1-3"/><ref name=SM2/><ref>{{cite web|url=http://anandtech.com/show/1034/4|title=NVIDIA Introduces GeForce FX (NV30)|first=Anand Lal|last=Shimpi}}</ref> !!2.0b<ref name="PS1-3"/><ref name=SM2/><ref name="PS2.0b">{{cite web|url=http://anandtech.com/show/1314/4|title=ATI Radeon X800 Pro and XT Platinum Edition: R420 Arrives|first=Derek|last=Wilson}}</ref> !!3.0<ref name="PS1-3"/><ref name=SM3>Shader Model 3.0, Ashu Rege, NVIDIA Developer Technology Group, 2004.</ref> !!4.0<ref name=D3D10>The Direct3D 10 System, David Blythe, Microsoft Corporation, 2006.</ref> <br />4.1<ref name="SM4.1">{{cite web|url=https://msdn.microsoft.com/en-us/library/windows/desktop/ff471379(v=vs.85).aspx|title=Registers - ps_4_1 (Windows)|website=msdn.microsoft.com|date=23 August 2019 }}</ref> <br />5.0<ref name="SM5">{{cite web|url=https://msdn.microsoft.com/en-us/library/windows/desktop/hh447212(v=vs.85).aspx|title=Registers - ps_5_0 (Windows)|website=msdn.microsoft.com|date=23 August 2019 }}</ref> |
||
|- |
|- |
||
!Dependent texture limit |
!Dependent texture limit |
||
Line 130: | Line 133: | ||
*'''PS 1.2''' — [[3Dlabs]] Wildcat VP, DirectX 8.0a. |
*'''PS 1.2''' — [[3Dlabs]] Wildcat VP, DirectX 8.0a. |
||
*'''PS 1.3''' — [[GeForce 4 Ti]], DirectX 8.0a. |
*'''PS 1.3''' — [[GeForce 4 Ti]], DirectX 8.0a. |
||
*'''PS 1.4''' — [[ATI Radeon R200 series|Radeon 8500-9250]], [[ |
*'''PS 1.4''' — [[ATI Radeon R200 series|Radeon 8500-9250]], [[Matrox Parhelia]], DirectX 8.1. |
||
*'''Shader Model 2.0''' — [[ATi Radeon R300 Series|Radeon 9500-9800/X300-X600]], DirectX 9. |
*'''Shader Model 2.0''' — [[ATi Radeon R300 Series|Radeon 9500-9800/X300-X600]], DirectX 9. |
||
*'''Shader Model 2.0a''' — [[GeForce FX|GeForce FX/PCX]]-optimized model, DirectX 9.0a. |
*'''Shader Model 2.0a''' — [[GeForce FX|GeForce FX/PCX]]-optimized model, DirectX 9.0a. |
||
Line 152: | Line 155: | ||
! Vertex shader version |
! Vertex shader version |
||
!VS 1.1<ref name="VS1-3">{{cite web|url=https://msdn.microsoft.com/en-us/library/bb172931(v=VS.85).aspx|title=Vertex Shader Differences|date=2011-02-08|work=msdn.microsoft.com}}</ref> |
!VS 1.1<ref name="VS1-3">{{cite web|url=https://msdn.microsoft.com/en-us/library/bb172931(v=VS.85).aspx|title=Vertex Shader Differences|date=2011-02-08|work=msdn.microsoft.com}}</ref> |
||
!VS 2.0<ref name=SM2/><ref name="VS1-3"/><ref name="VS2.0a"/> !!VS 2.0a<ref name=SM2/><ref name="VS1-3"/><ref name="VS2.0a">{{cite web|url=http://anandtech.com/show/1034/3|title=NVIDIA Introduces GeForce FX (NV30)|first=Anand Lal|last=Shimpi |
!VS 2.0<ref name=SM2/><ref name="VS1-3"/><ref name="VS2.0a"/> !!VS 2.0a<ref name=SM2/><ref name="VS1-3"/><ref name="VS2.0a">{{cite web|url=http://anandtech.com/show/1034/3|title=NVIDIA Introduces GeForce FX (NV30)|first=Anand Lal|last=Shimpi}}</ref> !!VS 3.0<ref name=SM3 /><ref name="VS1-3"/> !!VS 4.0<ref name=D3D10 /> <br />VS 4.1<ref>{{cite web|url=https://msdn.microsoft.com/en-us/library/windows/desktop/ff471381(v=vs.85).aspx|title=Registers - vs_4_1 (Windows)|website=msdn.microsoft.com|date=23 August 2019 }}</ref> <br />VS 5.0<ref name="SM5"/> |
||
|- |
|- |
||
!# of instruction slots |
!# of instruction slots |
||
Line 210: | Line 213: | ||
The [[Khronos Group]] has also written a LLVM-based HLSL compiler, in the form of a frontend for ''glslang'', 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.<ref>{{cite web |title=glslang: Khronos-reference front end for GLSL/ESSL, partial front end for HLSL, and a SPIR-V generator. |url=https://github.com/KhronosGroup/glslang |publisher=The Khronos Group |date=21 October 2020}}</ref> This task was previously performed by source-level converters like [[HLSL2GLSL]], but the resulting code is often bloated.<ref>Matt Turner. {{YouTube|3C96NJeYAy4}}.</ref> |
The [[Khronos Group]] has also written a LLVM-based HLSL compiler, in the form of a frontend for ''glslang'', 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.<ref>{{cite web |title=glslang: Khronos-reference front end for GLSL/ESSL, partial front end for HLSL, and a SPIR-V generator. |url=https://github.com/KhronosGroup/glslang |publisher=The Khronos Group |date=21 October 2020}}</ref> This task was previously performed by source-level converters like [[HLSL2GLSL]], but the resulting code is often bloated.<ref>Matt Turner. {{YouTube|3C96NJeYAy4}}.</ref> |
||
=== Derived languages === |
=== Derived languages === |
||
The [[PlayStation |
The [[PlayStation Shader Language]] (PSSL) is based on Cg/HLSL.<ref>{{cite web |last1=Stenson |first1=Richard |last2=Ho |first2=Chris |title=PlayStation Shading Language for PS4 |url=https://www.gdcvault.com/play/1019252/PlayStation-Shading-Language-for |website=GDC Europe 2013}}</ref> |
||
⚫ | 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.<ref>{{cite web|url=https://github.com/crosire/reshade-shaders/blob/master/REFERENCE.md|website=GitHub|title=ReShade FX shading language}}</ref> |
||
== Examples == |
|||
===A sample Cg vertex shader=== |
|||
<syntaxhighlight lang="glsl"> |
|||
// input vertex |
|||
struct VertIn { |
|||
float4 pos : POSITION; |
|||
float4 color : COLOR0; |
|||
}; |
|||
// output vertex |
|||
struct VertOut { |
|||
float4 pos : POSITION; |
|||
float4 color : COLOR0; |
|||
}; |
|||
⚫ | 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.<ref>{{cite web|url=https://github.com/crosire/reshade-shaders/blob/master/REFERENCE.md|website=GitHub|title=ReShade FX shading language|date=15 February 2022}}</ref> |
||
// vertex shader main entry |
|||
VertOut main(VertIn IN, uniform float4x4 modelViewProj) { |
|||
VertOut OUT; |
|||
OUT.pos = mul(modelViewProj, IN.pos); // calculate output coords |
|||
OUT.color = IN.color; // copy input color to output |
|||
OUT.color.z = 1.0f; // blue component of color = 1.0f |
|||
return OUT; |
|||
} |
|||
</syntaxhighlight> |
|||
==Applications and games that use Cg or HLSL== |
==Applications and games that use Cg or HLSL== |
||
Line 246: | Line 225: | ||
* [[Autodesk Maya|Maya]]<ref>{{cite web|url=http://www.nvidia.com/object/MayaCgPlugin.html|title=Maya Cg Plug-in | NVIDIA}}</ref> |
* [[Autodesk Maya|Maya]]<ref>{{cite web|url=http://www.nvidia.com/object/MayaCgPlugin.html|title=Maya Cg Plug-in | NVIDIA}}</ref> |
||
* ''[[Battlefield 2]]'' |
* ''[[Battlefield 2]]'' |
||
* ''[[Cafu Engine]]'' |
|||
* ''[[Crystal Space]]'' |
* ''[[Crystal Space]]'' |
||
* ''[[Racer (simulator)|Dolphinity Racer]]'' |
* ''[[Racer (simulator)|Dolphinity Racer]]'' |
||
Line 298: | Line 276: | ||
* Some essential materials (e.g. the design paper) are gathered in [http://www.csee.umbc.edu/~olano/s2005c37/ch05.pdf these course notes from Siggraph 2005] |
* Some essential materials (e.g. the design paper) are gathered in [http://www.csee.umbc.edu/~olano/s2005c37/ch05.pdf these course notes from Siggraph 2005] |
||
* Nvidia-hosted materials: |
* Nvidia-hosted materials: |
||
⚫ | |||
** [https://developer.nvidia.com/CgTutorial/cg_tutorial_chapter01.html Cg Tutorial (Free Book)] |
|||
** Cg [https://developer.nvidia.com/Cg/Cg_language.html language], [https://developer.nvidia.com/Cg/index_runtime.html runtime], [https://developer.nvidia.com/Cg/index_profiles.html profile], [https://developer.nvidia.com/Cg/index_stdlib.html standard library], [https://developer.nvidia.com/Cg/index_states.html CgFX state] and [https://developer.nvidia.com/Cg/index_bin.html command-line] documentation. |
|||
** [http://developer.nvidia.com/cg-faq Cg FAQ] |
** [http://developer.nvidia.com/cg-faq Cg FAQ] |
||
⚫ | |||
** Cg [https://developer.download.nvidia.com/cg/ Language Reference and Documentation] |
|||
* [https://web.archive.org/web/20081219131420/http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=47 NeHe Cg vertex shader tutorial] |
* [https://web.archive.org/web/20081219131420/http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=47 NeHe Cg vertex shader tutorial] |
||
* [https://github.com/Themaister/Emulator-Shader-Pack/blob/master/Cg/README Documentation for the Cg Shader standard used by emulators] |
* [https://github.com/Themaister/Emulator-Shader-Pack/blob/master/Cg/README Documentation for the Cg Shader standard used by emulators] |
Revision as of 03:32, 19 August 2024
Family | shading language |
---|---|
Developer | nVIDIA, Microsoft |
Website | developer |
Dialects | |
Cg, HLSL, Playstation Shading Language | |
Influenced by | |
C, RenderMan Shading Language | |
Influenced | |
GLSL |
Cg (short for C for Graphics) and High-Level Shader Language (HLSL) are two names given to a high-level shading language developed by Nvidia and Microsoft for programming shaders. Cg/HLSL is based on the C 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 programming graphics processing units.[1][2]
Two main branches of the Cg/HLSL language exist: the Nvidia Cg compiler (cgc) which outputs DirectX or OpenGL and the Microsoft HLSL which outputs DirectX shaders in bytecode format.[3][4] Nvidia's cgc was deprecated in 2012, with no additional development or support available.[5]
HLSL shaders can enable many special effects in both 2D and 3D computer graphics. The Cg/HLSL language originally only included support for vertex shaders and pixel shaders, but other types of shaders were introduced gradually as well:
- DirectX 10 (Shader Model 4) and Cg 2.0 introduced geometry shaders.[6]
- DirectX 11 (Shader Model 5) introduced compute shaders (GPGPU) and tessellation shaders (hull and domain). The latter is present in Cg 3.1.
- DirectX 12 (Shader Model 6.3) introduced ray tracing shaders (ray generation, intersection, bit / closest hit / miss).
Background
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:
- High level code is easier to learn, program, read, and maintain than assembly code.
- Cg code is portable to a wide range of hardware and platforms, unlike assembly code, which usually depends on hardware and the platforms it's written for.
- The Cg compiler can optimize code and do lower level tasks automatically, which are hard to do and error prone in assembly.
Language
Data types
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:
- float - a 32bit floating point number
- half - a 16bit floating point number
- int - a 32bit integer
- fixed - a 12bit fixed point number
- bool - a boolean variable
- sampler* - represents a texture object
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 and array data types, which work in a similar way to their C equivalents.
Operators
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 common logical operators.
Functions and control structures
Cg shares the basic control structures with C, like if/else, while, and for. It also has a similar way of defining functions.
Semantics
Preprocessor
Cg implements many C preprocessor directives and its macro expansion system. It implements #include
.[7]
HLSL features
- Namespace
- Annotation
Environment
Compilation targets
Cg programs are built for different shader 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 |
Arbitrary swizzling | 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 |
- PS 1.0 — Unreleased 3dfx Rampage, DirectX 8.
- PS 1.1 — GeForce 3, DirectX 8.
- PS 1.2 — 3Dlabs Wildcat VP, DirectX 8.0a.
- PS 1.3 — GeForce 4 Ti, DirectX 8.0a.
- PS 1.4 — Radeon 8500-9250, Matrox Parhelia, DirectX 8.1.
- Shader Model 2.0 — Radeon 9500-9800/X300-X600, DirectX 9.
- Shader Model 2.0a — GeForce FX/PCX-optimized model, DirectX 9.0a.
- Shader Model 2.0b — Radeon X700-X850 shader model, DirectX 9.0b.
- Shader Model 3.0 — Radeon X1000 and GeForce 6, DirectX 9.0c.
- Shader Model 4.0 — Radeon HD 2000 and GeForce 8, DirectX 10.
- Shader Model 4.1 — Radeon HD 3000 and GeForce 200, DirectX 10.1.
- Shader Model 5.0 — Radeon HD 5000 and GeForce 400, DirectX 11.
- Shader Model 5.1 — GCN 1+, Fermi+, DirectX 12 (11_0+) with WDDM 2.0.
- Shader Model 6.0 — GCN 1+, Kepler+, DirectX 12 (11_0+) with WDDM 2.1.
- Shader Model 6.1 — GCN 1+, Kepler+, DirectX 12 (11_0+) with WDDM 2.3.
- Shader Model 6.2 — GCN 1+, Kepler+, DirectX 12 (11_0+) with WDDM 2.4.
- Shader Model 6.3 — GCN 1+, Kepler+, DirectX 12 (11_0+) with WDDM 2.5.
- Shader Model 6.4 — GCN 1+, Kepler+, Skylake+, DirectX 12 (11_0+) with WDDM 2.6.
- Shader Model 6.5 — GCN 1+, Kepler+, Skylake+, DirectX 12 (11_0+) with WDDM 2.7.
"32 + 64" for Executed 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 |
The standard library
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 the texture mapping functions tex1D and tex2D.
The Cg runtime library
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 graphics APIs: OpenGL or DirectX. 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.'
Compilers and dialects
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-source LLVM-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 emit SPIR-V bytecode.[22]
The Khronos Group has also written a LLVM-based HLSL compiler, in the form of a frontend for glslang, 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 like HLSL2GLSL, but the resulting code is often bloated.[24]
Derived languages
The PlayStation 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]
Applications and games that use Cg or HLSL
- 3DVIA Virtools
- Adobe Photoshop
- Maya[27]
- Battlefield 2
- Crystal Space
- Dolphinity Racer
- Earth's Special Forces - A Half-Life Mod
- Enemy Territory: Quake Wars
- Doom 3 BFG Edition
- EON Professional™/Ultra™ of EON Reality
- eyeon Fusion
- Far Cry
- Garshasp: The Monster Slayer
- GLScene
- Gun Metal
- Hitman: Blood Money
- Irrlicht Engine
- League of Legends
- Lightfeather 3D Engine
- LightWave 11.6[28]
- muvee Reveal
- OGRE
- OpenEmu
- Panda3D
- PCSX2
- PlayStation 3
- RetroArch
- R.U.S.E.
- Snes9x
- Unity game engine[29]
- Unreal Engine
See also
- Computer programming
- Computer graphics
- Vertex and pixel shaders
- High level shader language
- OpenGL shading language
- Shader Model
- OpenGL
- DirectX
References
- ^ "Fusion Industries :: Cg and HLSL FAQ ::". 24 August 2012. Archived from the original on 24 August 2012.
- ^ "The Cg Tutorial - Chapter 1. Introduction". developer.download.nvidia.cn.
- ^ "Writing HLSL Shaders in Direct3D 9 (Windows)". msdn.microsoft.com. 24 May 2021.
- ^ "Cg FAQ". NVIDIA DesignWorks. 8 March 2011. Retrieved 25 May 2017.
- ^ "Cg Toolkit | NVIDIA Developer". 8 March 2011.
- ^ "Cg 2.0 Release Notes" (PDF). nvidia.com. January 2008.
- ^ a b Mark J. Kilgard, Cg in Two Pages, 2003.
- ^ a b "Cg Profile Documentation". Nvidia developer.
- ^ "Shader Models vs Shader Profiles - Win32 apps". docs.microsoft.com. 30 June 2021.
- ^ a b c d e f "Pixel Shader Differences". msdn.microsoft.com. 2011-02-08.
- ^ a b c d e Peeper, Craig (2004-03-15). "Microsoft DirectX High Level Shader Language (HLSL)" (PPT). microsoft.com. pp. 5–8, 24–25.
- ^ Shimpi, Anand Lal. "NVIDIA Introduces GeForce FX (NV30)".
- ^ Wilson, Derek. "ATI Radeon X800 Pro and XT Platinum Edition: R420 Arrives".
- ^ a b Shader Model 3.0, Ashu Rege, NVIDIA Developer Technology Group, 2004.
- ^ a b The Direct3D 10 System, David Blythe, Microsoft Corporation, 2006.
- ^ "Registers - ps_4_1 (Windows)". msdn.microsoft.com. 23 August 2019.
- ^ a b "Registers - ps_5_0 (Windows)". msdn.microsoft.com. 23 August 2019.
- ^ a b c d "Vertex Shader Differences". msdn.microsoft.com. 2011-02-08.
- ^ a b Shimpi, Anand Lal. "NVIDIA Introduces GeForce FX (NV30)".
- ^ "Registers - vs_4_1 (Windows)". msdn.microsoft.com. 23 August 2019.
- ^ "Porting from FXC to DXC". GitHub.
- ^ "microsoft/DirectXShaderCompiler: This repo hosts the source for the DirectX Shader Compiler which is based on LLVM/Clang". Microsoft. 21 October 2020.
- ^ "glslang: Khronos-reference front end for GLSL/ESSL, partial front end for HLSL, and a SPIR-V generator". The Khronos Group. 21 October 2020.
- ^ Matt Turner. Video on YouTube.
- ^ Stenson, Richard; Ho, Chris. "PlayStation Shading Language for PS4". GDC Europe 2013.
- ^ "ReShade FX shading language". GitHub. 15 February 2022.
- ^ "Maya Cg Plug-in | NVIDIA".
- ^ "LightWave - 11.6 Features Overview".
- ^ "Unity - Manual: Writing Shaders".
Further reading
- Randima Fernando, Mark J. Kilgard, The Cg Tutorial: The Definitive Guide to Programmable Real-Time Graphics, Addison-Wesley Professional, ISBN 0-321-19496-9
- Randima Fernando, GPU Gems: Programming Techniques, Tips, and Tricks for Real-Time Graphics, Addison-Wesley Professional, ISBN 0-321-22832-4
- William R. Mark, R. Steven Glanville, Kurt Akeley, Mark J. Kilgard, Cg: A System for Programming Graphics Hardware in a C-like Language, Proceedings of SIGGRAPH 2003, doi:10.1145/1201775.882362
External links
- cgc-opensrc - Mirror for nvidia's open source compiler, 2002
- Some essential materials (e.g. the design paper) are gathered in these course notes from Siggraph 2005
- Nvidia-hosted materials:
- NeHe Cg vertex shader tutorial
- Documentation for the Cg Shader standard used by emulators
- Aras Pranckevičius, Cross Platform Shaders in 2014.