High-Level Shader Language: Difference between revisions

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search
VisualWikitext
imported>Steel1943
m →Pixel shader comparison: fix common MOS:REFSPACE spacing errors, replaced: /ref>4 → /ref> 4
 
imported>Artoria2e5
 
Line 2: Line 2:
{{Use American English|date=February 2023}}
{{Use American English|date=February 2023}}
{{Use mdy dates|date=February 2023}}
{{Use mdy dates|date=February 2023}}
[[File:HLSL-Examples-1.PNG|thumb|300px|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 been [[linear transformation|transformed]] and [[rotation|rotated]]. The partial [[Transparency (graphic)|transparency]] and [[reflection (computer graphics)|reflection]] of the water in the foreground are added by a shader applied finally to the entire scene.]]  
{{Infobox programming language
| name = Cg/HLSL
| logo =      <!-- (filename) -->
| logo caption =
| screenshot = File:HLSL-Examples-1.PNG
| screenshot caption = 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 been [[linear transformation|transformed]] and [[rotation|rotated]]. The partial [[Transparency (graphic)|transparency]] and [[reflection (computer graphics)|reflection]] of the water in the foreground are added by a shader applied finally to the entire scene.
| paradigm =  <!-- or: | paradigms = -->
| family = [[shading language]]
| designer =  <!-- or: | designers = -->
| developer = nVIDIA, Microsoft
| dialects = Cg, HLSL, Playstation Shading Language, ReShadeFX, Slang
| influenced by = [[C (programming language)|C]], [[RenderMan Shading Language]]
| influenced = [[GLSL]]
}}


The '''High-Level Shader Language'''<ref>{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-writing-shaders-9 |title=Writing HLSL Shaders in Direct3D 9 |website=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref> or '''High-Level Shading Language'''<ref>{{cite web |title=High-level shader language (HLSL) |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl |website=[[Microsoft Docs]] |accessdate=February 22, 2021}}</ref> ('''HLSL''') is a proprietary [[shading language]] developed by [[Microsoft]] for the [[Direct3D]] 9 [[API]] to augment the [[Shading language#DirectX Shader Assembly Language|shader assembly]] language, and went on to become the required shading language for the unified shader model of Direct3D 10 and higher.
The '''High-Level Shader Language'''<ref>{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-writing-shaders-9 |title=Writing HLSL Shaders in Direct3D 9 |website=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref> or '''High-Level Shading Language'''<ref>{{cite web |title=High-level shader language (HLSL) |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl |website=[[Microsoft Docs]] |accessdate=February 22, 2021}}</ref> ('''HLSL''') is a proprietary [[shading language]] developed by [[Microsoft]] for the [[Direct3D]] 9 [[API]] to augment the [[Shading language#DirectX Shader Assembly Language|shader assembly]] language, and went on to become the required shading language for the unified shader model of Direct3D 10 and higher. It was developed alongside the '''Cg''' (short for ''C for Graphics'') shading language from Nvidia. Early versions of the two languages were considered identical, only marketed differently.<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=August 24, 2012|title=Fusion Industries :: Cg and HLSL FAQ ::|date=August 24, 2012|publisher=}}</ref>


HLSL is analogous to the [[GLSL]] shading language used with the [[OpenGL]] standard. It is very similar to the [[Nvidia Cg]] shading language, as it was developed alongside it. Early versions of the two languages were considered identical, only marketed differently.<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=August 24, 2012|title=Fusion Industries :: Cg and HLSL FAQ ::|date=August 24, 2012|publisher=}}</ref> HLSL shaders can enable profound speed and detail increases as well as many [[special effects]] in both 2D and 3D [[computer graphics]].{{Citation needed|reason=This seems to posit that HLSL shaders are faster than alternatives but doesn't provide any backing to that claim.|date=August 2018}}
Although Cg and HLSL 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>


HLSL programs come in six forms: [[pixel shader]]s (fragment in GLSL), [[vertex shader]]s, [[geometry shader]]s, [[compute shader]]s, [[tessellation shader]]s (Hull and Domain shaders), and [[ray tracing shader]]s (Ray Generation Shaders, Intersection Shaders, Any Hit/Closest Hit/Miss Shaders). A vertex shader is executed for each vertex that is submitted by the application, and is primarily responsible for transforming the vertex from object space to view space, generating texture coordinates, and calculating lighting coefficients such as the vertex's normal, tangent, and bitangent vectors. When a group of vertices (normally 3, to form a triangle) come through the vertex shader, their output position is interpolated to form pixels within its area; this process is known as [[rasterization]].
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 &#124; NVIDIA Developer|date=8 March 2011}}</ref>


Optionally, an application using a Direct3D 10/11/12 interface and Direct3D 10/11/12 hardware may also specify a geometry shader. This shader takes as its input some vertices of a primitive (triangle/line/point) and uses this data to generate/degenerate (or [[Tessellation (computer graphics)|tessellate]]) additional primitives or to change the type of primitives, which are each then sent to the rasterizer.
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 ("fragment" in GLSL).  A vertex shader is executed for each vertex that is submitted by the application, and is primarily responsible for transforming the vertex from object space to view space, generating texture coordinates, and calculating lighting coefficients such as the vertex's normal, tangent, and bitangent vectors. When a group of vertices (normally 3, to form a triangle) come through the vertex shader, their output position is interpolated to form pixels within its area; this process is known as [[rasterization]].
* 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> This shader takes as its input some vertices of a primitive (triangle/line/point) and uses this data to generate/degenerate (or [[Tessellation (computer graphics)|tessellate]]) additional primitives or to change the type of primitives, which are each then sent to the rasterizer.
* 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, any hit / closest hit / miss).


D3D11.3 and D3D12 introduced Shader Model 5.1<ref>{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/shader-model-5-1-objects |title=Shader Model 5.1 Objects |website=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref> and later 6.0.<ref>{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12 |title=HLSL Shader Model 6.0 |website=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref>
D3D11.3 and D3D12 introduced Shader Model 5.1<ref>{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/shader-model-5-1-objects |title=Shader Model 5.1 Objects |website=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref> and later 6.0.<ref>{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12 |title=HLSL Shader Model 6.0 |website=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref>


==Shader model comparison==
==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/HLSL over assembly are:
* High level code is easier to learn, program, read, and maintain than assembly code.
* Cg/HLSL 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/HLSL compiler can optimize code and do lower level tasks automatically, which are hard to do and error-prone in assembly.
 
==Language==
 
===Data types===
Cg/HLSL 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:
* [[IEEE floating point|float]] - a 32bit floating point number
* [[Half-precision floating-point format|half]] - a 16bit floating point number
* [[Integer (computer science)|int]] - a 32bit integer
* [[Fixed-point arithmetic|fixed]] - a 12bit fixed point number
* [[Boolean data type|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 type]]s, 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 operator]]s.
 
===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 ===
<!-- Variable Syntax -->
 
=== 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>
 
=== HLSL features ===
* Namespace
* Annotation
 
== Environment ==
 
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 |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/>
 
GPUs listed are the hardware that first supported the given specifications. Manufacturers generally support all lower shader models through drivers. Note that games may claim to require a certain DirectX version, but don't necessarily require a GPU conforming to the full specification of that version, as developers can use a higher DirectX API version to target lower-Direct3D-spec hardware; for instance DirectX 9 exposes features of DirectX7-level hardware that DirectX7 did not, targeting their fixed-function T&L pipeline.
GPUs listed are the hardware that first supported the given specifications. Manufacturers generally support all lower shader models through drivers. Note that games may claim to require a certain DirectX version, but don't necessarily require a GPU conforming to the full specification of that version, as developers can use a higher DirectX API version to target lower-Direct3D-spec hardware; for instance DirectX 9 exposes features of DirectX7-level hardware that DirectX7 did not, targeting their fixed-function T&L pipeline.
===Pixel shader comparison===
===Pixel shader comparison===
Line 23: Line 84:
!1.2
!1.2
1.3<ref name="PS1-3">{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx9-graphics-reference-asm-ps-differences |title=Pixel Shader Differences |work=[[Microsoft Docs]] |date=August 19, 2020 |access-date=February 22, 2021}}</ref>       
1.3<ref name="PS1-3">{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx9-graphics-reference-asm-ps-differences |title=Pixel Shader Differences |work=[[Microsoft Docs]] |date=August 19, 2020 |access-date=February 22, 2021}}</ref>       
!1.4<ref name="PS1-3"/>      !!2.0<ref name="PS1-3"/><ref name=SM2>{{cite web |url=https://docs.microsoft.com/en-us/previous-versions/ms810449(v=msdn.10) |title=Introduction to the DirectX 9 High-Level Shader Language |last1=Peeper |first1=Craig |last2=Mitchell |first2=Jason L. |date=July 2003 |work=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref>!!2.0a<ref name="PS1-3"/><ref name=SM2/><ref name="VS2.0a">{{cite web |url=https://www.anandtech.com/show/1034/4 |title=NVIDIA Introduces GeForce FX (NV30) |last=Shimpi |first=Anand Lal |author-link=Anand Lal Shimpi |work=[[AnandTech]] |access-date=February 22, 2021}}</ref>!!2.0b<ref name="PS1-3"/><ref name=SM2/><ref name="PS2.0b">{{cite web |url=https://www.anandtech.com/show/1314/4 |title=ATI Radeon X800 Pro and XT Platinum Edition: R420 Arrives |first=Derek |last=Wilson |work=[[AnandTech]] |access-date=February 22, 2021}}</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> 4.1<ref name="SM4.1">{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-sm4-registers-ps-4-1 |title=Registers - ps_4_1 |website=[[Microsoft Docs]] |date=August 23, 2019 |access-date=February 22, 2021}}</ref>
!1.4<ref name="PS1-3"/>      !!2.0<ref name="PS1-3"/><ref name=SM2>{{cite web |url=https://docs.microsoft.com/en-us/previous-versions/ms810449(v=msdn.10) |title=Introduction to the DirectX 9 High-Level Shader Language |last1=Peeper |first1=Craig |last2=Mitchell |first2=Jason L. |date=July 2003 |work=[[Microsoft Docs]] |access-date=February 22, 2021}}</ref>!!2.0a<ref name="PS1-3"/><ref name=SM2/><ref name="VS2.0a">{{cite web |url=https://www.anandtech.com/show/1034/4 |archive-url=https://web.archive.org/web/20130610035912/http://www.anandtech.com/show/1034/4 |url-status=dead |archive-date=June 10, 2013 |title=NVIDIA Introduces GeForce FX (NV30) |last=Shimpi |first=Anand Lal |author-link=Anand Lal Shimpi |work=[[AnandTech]] |access-date=February 22, 2021}}</ref>!!2.0b<ref name="PS1-3"/><ref name=SM2/><ref name="PS2.0b">{{cite web |url=https://www.anandtech.com/show/1314/4 |archive-url=https://web.archive.org/web/20120928192354/http://www.anandtech.com/show/1314/4 |url-status=dead |archive-date=September 28, 2012 |title=ATI Radeon X800 Pro and XT Platinum Edition: R420 Arrives |first=Derek |last=Wilson |work=[[AnandTech]] |access-date=February 22, 2021}}</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> 4.1<ref name="SM4.1">{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-sm4-registers-ps-4-1 |title=Registers - ps_4_1 |website=[[Microsoft Docs]] |date=August 23, 2019 |access-date=February 22, 2021}}</ref>
5.0<ref name="SM5">{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/registers---ps-5-0 |title=Registers - ps_5_0 |website=[[Microsoft Docs]] |date=August 23, 2019 |access-date=February 22, 2021}}</ref>
5.0<ref name="SM5">{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/registers---ps-5-0 |title=Registers - ps_5_0 |website=[[Microsoft Docs]] |date=August 23, 2019 |access-date=February 22, 2021}}</ref>
|-
|-
Line 213: Line 274:
|}
|}


== See also ==
===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/HLSL runtime library===
Cg/HLSL 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 [[API]]s: [[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. (HLSL only targets DirectX.)
 
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.<ref>{{cite web |title=Porting from FXC to DXC |url=https://github.com/microsoft/DirectXShaderCompiler/wiki/Porting-shaders-from-FXC-to-DXC |website=GitHub |language=en}}</ref> Both compilers generate bytecode: while the older FXC used DXBC, DXC now uses DXIL. DXC can also emit [[SPIR-V]] bytecode.<ref>{{cite web |title=microsoft/DirectXShaderCompiler: This repo hosts the source for the DirectX Shader Compiler which is based on LLVM/Clang. |url=https://github.com/microsoft/DirectXShaderCompiler |publisher=Microsoft |date=21 October 2020}}</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 ===
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|date=15 February 2022}}</ref>
 
Khronos has since evolved ''glslang'' into ''slang'', a shading language and compiler that is mostly source-code-compatible with HLSL. Slang can compile to textual shading languages (GLSL, [[Metal (API)|MSL]], CUDA, [[WebGPU Shading Language|WGSL]]), bytecodes (D3D11, D3D12, Vulkan [[SPIR-V]]) as well as the CPU. It also has a GLSL-compatibility mode.<ref>{{cite web |title=shader-slang/slang |url=https://github.com/shader-slang/slang |publisher=The Slang Shading Language |date=8 December 2025}}</ref>
 
==Applications and games that use Cg or HLSL==
{{div col start}}
* ''[[Virtools|3DVIA Virtools]]''
* [[Adobe Photoshop]]
* [[Autodesk Maya|Maya]]<ref>{{cite web|url=http://www.nvidia.com/object/MayaCgPlugin.html|title=Maya Cg Plug-in &#124; NVIDIA}}</ref>
* ''[[Battlefield 2]]''
* ''[[Crystal Space]]''
* ''[[Racer (simulator)|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<ref>{{cite web|url=https://www.lightwave3d.com/11-6_features_overview/|title=LightWave - 11.6 Features Overview}}</ref>
* ''[[muvee Technologies|muvee Reveal]]''
* ''[[OGRE]]''
* ''[[OpenEmu]]''
* ''[[Panda3D]]''
* [[PCSX2]]
* [[PlayStation 3]]
* ''[[RetroArch]]''
* ''[[R.U.S.E.]]''
* ''[[Snes9x]]''
* ''[[Unity (game engine)|Unity game engine]]''<ref>{{cite web|url=http://docs.unity3d.com/Manual/ShadersOverview.html|title=Unity - Manual: Writing Shaders}}</ref>
* ''[[Unreal Engine]]''
{{div col end}}
 
==See also==
* [[Direct3D]]
* [[Direct3D]]
* [[DirectX]]
* [[DirectX]]
* [[DirectX Raytracing]]
* [[DirectX Raytracing]]
* [[Computer programming]]
* [[Computer graphics]]
* [[Vertex shader|Vertex and pixel shaders]]
* [[GLSL|OpenGL shading language]]
* [[Shader Model]]
* [[OpenGL]]


==Footnotes==
==References==
{{reflist}}
{{Reflist}}
 
==Further reading==
* [http://www.randima.com Randima Fernando], [[Mark Kilgard|Mark J. Kilgard]], ''[http://http.developer.nvidia.com/CgTutorial/cg_tutorial_frontmatter.html The Cg Tutorial]: The Definitive Guide to Programmable Real-Time Graphics'', Addison-Wesley Professional, {{ISBN|0-321-19496-9}}
* [http://www.randima.com 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 Kilgard|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==
==External links==
* [https://github.com/castano/cgc-opensrc cgc-opensrc] - Mirror for nvidia's open source compiler, 2002
* 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:
** [http://developer.nvidia.com/cg-faq Cg FAQ]
** [https://developer.nvidia.com/cg-toolkit Cg Toolkit]
** 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://github.com/Themaister/Emulator-Shader-Pack/blob/master/Cg/README Documentation for the Cg Shader standard used by emulators]
* Aras Pranckevičius,<!-- he is a Unity dev --> [http://aras-p.info/blog/2014/03/28/cross-platform-shaders-in-2014/ Cross Platform Shaders in 2014].
* [https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-pguide Programming guide for HLSL] at [[Microsoft Docs]]
* [https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-pguide Programming guide for HLSL] at [[Microsoft Docs]]
* [https://web.archive.org/web/20100215205220/http://ati.amd.com/developer/ShaderX2_IntroductionToHLSL.pdf Introduction to the DirectX 9 High Level Shading Language], (ATI) AMD developer central
* [https://web.archive.org/web/20100215205220/http://ati.amd.com/developer/ShaderX2_IntroductionToHLSL.pdf Introduction to the DirectX 9 High Level Shading Language], (ATI) AMD developer central
Line 227: Line 367:
* [http://www.neatware.com/lbstudio/web/hlsl.html HLSL Introduction]
* [http://www.neatware.com/lbstudio/web/hlsl.html HLSL Introduction]
* [https://github.com/microsoft/DirectXShaderCompiler/blob/master/docs/DXIL.rst DirectX Intermediate Language] (DXIL) specification
* [https://github.com/microsoft/DirectXShaderCompiler/blob/master/docs/DXIL.rst DirectX Intermediate Language] (DXIL) specification
{{Nvidia}}


[[Category:C programming language family]]
[[Category:C programming language family]]
[[Category:Nvidia software]]
[[Category:Shading languages]]
[[Category:DirectX]]
[[Category:DirectX]]
[[Category:Microsoft application programming interfaces]]
[[Category:Microsoft application programming interfaces]]
[[Category:Shading languages]]

Latest revision as of 03:38, 9 December 2025

Template:Short description Template:Use American English Template:Use mdy dates Script error: No such module "Infobox".Template:Template otherScript error: No such module "Check for unknown parameters".

The High-Level Shader Language[1] or High-Level Shading Language[2] (HLSL) is a proprietary shading language developed by Microsoft for the Direct3D 9 API to augment the shader assembly language, and went on to become the required shading language for the unified shader model of Direct3D 10 and higher. It was developed alongside the Cg (short for C for Graphics) shading language from Nvidia. Early versions of the two languages were considered identical, only marketed differently.[3]

Although Cg and HLSL 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.[4][5]

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.[6][7] Nvidia's cgc was deprecated in 2012, with no additional development or support available.[8]

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 ("fragment" in GLSL). A vertex shader is executed for each vertex that is submitted by the application, and is primarily responsible for transforming the vertex from object space to view space, generating texture coordinates, and calculating lighting coefficients such as the vertex's normal, tangent, and bitangent vectors. When a group of vertices (normally 3, to form a triangle) come through the vertex shader, their output position is interpolated to form pixels within its area; this process is known as rasterization.
  • DirectX 10 (Shader Model 4) and Cg 2.0 introduced geometry shaders.[9] This shader takes as its input some vertices of a primitive (triangle/line/point) and uses this data to generate/degenerate (or tessellate) additional primitives or to change the type of primitives, which are each then sent to the rasterizer.
  • 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, any hit / closest hit / miss).

D3D11.3 and D3D12 introduced Shader Model 5.1[10] and later 6.0.[11]

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/HLSL over assembly are:

  • High level code is easier to learn, program, read, and maintain than assembly code.
  • Cg/HLSL 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/HLSL compiler can optimize code and do lower level tasks automatically, which are hard to do and error-prone in assembly.

Language

Data types

Cg/HLSL 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.[12]

HLSL features

  • Namespace
  • Annotation

Environment

Cg programs are built for different shader profiles that stand for GPUs with different capabilities.[13] 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.[12]

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.[14] Cg supports some of the newer profiles up to Shader Model 5.0 as well as translation to glsl or hlsl.[13]

GPUs listed are the hardware that first supported the given specifications. Manufacturers generally support all lower shader models through drivers. Note that games may claim to require a certain DirectX version, but don't necessarily require a GPU conforming to the full specification of that version, as developers can use a higher DirectX API version to target lower-Direct3D-spec hardware; for instance DirectX 9 exposes features of DirectX7-level hardware that DirectX7 did not, targeting their fixed-function T&L pipeline.

Pixel shader comparison

Pixel shader version 1.0 1.1 1.2

1.3[15]

1.4[15] 2.0[15][16] 2.0a[15][16][17] 2.0b[15][16][18] 3.0[15][19] 4.0[20] 4.1[21]

5.0[22]

Dependent texture limit 4 4 4 6 8 Unlimited 8 Unlimited Unlimited
Texture instruction limit 4 4 4 6 * 2 32 Unlimited Unlimited Unlimited Unlimited
Arithmetic instruction limit 8 8 8 8 * 2 64 Unlimited Unlimited Unlimited Unlimited
Position register No No No No No No No Yes Yes
Instruction slots 8 8 + 4 8 + 4 (8 + 6) * 2 64 + 32 512 512 ≥ 512 ≥ 65536
Executed instructions 8 8 + 4 8 + 4 (8 + 6) * 2 64 + 32 512 512 65536 Unlimited
Texture indirections 4 4 4 4 4 Unlimited 4 Unlimited Unlimited
Interpolated registers 2 + 4 2 + 4 2 + 4 2 + 6 2 + 8 2 + 8 2 + 8 10 32
Instruction predication No No No No No Yes No Yes No
Index input registers No No No No No No No Yes Yes
Temp registers 2 2 + 4 3 + 4 6 12 to 32 22 32 32 4096
Constant registers 8 8 8 8 32 32 32 224 16×4096
Arbitrary swizzling No No No No No Yes No Yes Yes
Gradient instructions No No No No No Yes No Yes Yes
Loop count register No No No No No No No Yes Yes
Face register (2-sided lighting) No No No No No No Yes Yes Yes
Dynamic flow control No No No No No No No Yes (24) Yes (64)
Bitwise Operators No No No No No No No No Yes
Native Integers No No 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.1
  • PS 1.3 — GeForce 4 Ti, DirectX 8.1
  • 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
  • Shader Model 6.6 — GCN 4+, Maxwell+, DirectX 12 (11_0+) with WDDM 3.0
  • Shader Model 6.7 — GCN 4+, Maxwell+, DirectX 12 (12_0+) with WDDM 3.1
  • Shader Model 6.8 — RDNA 1+, Maxwell 2+, DirectX 12 (12_0+) with WDDM 3.1 / 3.2 with Agility SDK


"32 + 64" for Executed Instructions means "32 texture instructions and 64 arithmetic instructions."

Vertex shader comparison

Vertex shader version 1.0 1.1[23] 2.0[16][23][17] 2.0a[16][23][17] 3.0[19][23] 4.0[20]
4.1[21]
5.0[22]
# of instruction slots 128 128 256 256 ≥ 512 ≥ 65536
Max # of instructions executed 128 128 1024 65536 65536 Unlimited
Instruction predication No No No Yes Yes Yes
Temp registers 12 12 12 16 32 4096
# constant registers ≥ 96 ≥ 96 ≥ 256 256 ≥ 256 16×4096
Address register No Yes Yes Yes Yes Yes
Static flow control No No Yes Yes Yes Yes
Dynamic flow control No No No Yes Yes Yes
Dynamic flow control depth — — — 24 24 64
Vertex texture fetch No No No No Yes Yes
# of texture samplers — — — — 4 128
Geometry instancing support No No No No Yes Yes
Bitwise operators No No No No No Yes
Native integers No 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/HLSL runtime library

Cg/HLSL 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. (HLSL only targets DirectX.)

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.[24] Both compilers generate bytecode: while the older FXC used DXBC, DXC now uses DXIL. DXC can also emit SPIR-V bytecode.[25]

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.[26] This task was previously performed by source-level converters like HLSL2GLSL, but the resulting code is often bloated.[27]

Derived languages

The PlayStation Shader Language (PSSL) is based on Cg/HLSL.[28]

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.[29]

Khronos has since evolved glslang into slang, a shading language and compiler that is mostly source-code-compatible with HLSL. Slang can compile to textual shading languages (GLSL, MSL, CUDA, WGSL), bytecodes (D3D11, D3D12, Vulkan SPIR-V) as well as the CPU. It also has a GLSL-compatibility mode.[30]

Applications and games that use Cg or HLSL

Template:Div col start

See also

References

<templatestyles src="Reflist/styles.css" />

  1. ↑ Script error: No such module "citation/CS1".
  2. ↑ Script error: No such module "citation/CS1".
  3. ↑ Script error: No such module "citation/CS1".
  4. ↑ Script error: No such module "citation/CS1".
  5. ↑ Script error: No such module "citation/CS1".
  6. ↑ Script error: No such module "citation/CS1".
  7. ↑ Script error: No such module "citation/CS1".
  8. ↑ Script error: No such module "citation/CS1".
  9. ↑ Script error: No such module "citation/CS1".
  10. ↑ Script error: No such module "citation/CS1".
  11. ↑ Script error: No such module "citation/CS1".
  12. ↑ a b Mark J. Kilgard, Cg in Two Pages, 2003.
  13. ↑ a b Script error: No such module "citation/CS1".
  14. ↑ Script error: No such module "citation/CS1".
  15. ↑ a b c d e f Script error: No such module "citation/CS1".
  16. ↑ a b c d e Script error: No such module "citation/CS1".
  17. ↑ a b c Script error: No such module "citation/CS1".
  18. ↑ Script error: No such module "citation/CS1".
  19. ↑ a b Shader Model 3.0, Ashu Rege, NVIDIA Developer Technology Group, 2004.
  20. ↑ a b The Direct3D 10 System, David Blythe, Microsoft Corporation, 2006.
  21. ↑ a b Script error: No such module "citation/CS1".
  22. ↑ a b Script error: No such module "citation/CS1".
  23. ↑ a b c d Script error: No such module "citation/CS1".
  24. ↑ Script error: No such module "citation/CS1".
  25. ↑ Script error: No such module "citation/CS1".
  26. ↑ Script error: No such module "citation/CS1".
  27. ↑ Matt Turner. Template:Trim Video on YouTubeScript error: No such module "Check for unknown parameters"..
  28. ↑ Script error: No such module "citation/CS1".
  29. ↑ Script error: No such module "citation/CS1".
  30. ↑ Script error: No such module "citation/CS1".
  31. ↑ Script error: No such module "citation/CS1".
  32. ↑ Script error: No such module "citation/CS1".
  33. ↑ Script error: No such module "citation/CS1".

Script error: No such module "Check for unknown parameters".

Further reading

External links

Script error: No such module "Navbox".

Retrieved from "http://debianws.lexgopc.com/wiki143/index.php?title=High-Level_Shader_Language&oldid=4785971"