stdlib documentation (#1745)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Split out AST 'printing'.

* Replace listener with List<Section>

* Section -> Part.

* Kind -> Type Flags -> Kind for ASTPrinter::Part

* Improve comments around ASTPrinter.

* toString -> toText on Val derived types. toText appends to a StringBuilder.

* Added toSlice free function.
Added operator<< for Val derived types.
Use << where appropriate in doing toText.

* More work at mark down output.

* Fill in sourceloc for enum case.
Add more sophisticated location determination for EnumCase.
Refactored documentation output into DocMarkdownWriter.

* Improvements for sig output.

* Split up slang-doc into extractor and writer.

* WIP generic support for doc support.

* Some refactoring to make DocExtractor have potential to be used without Decls.

* Made doc extraction work without Decls.

* Output generic parameters.

* Add generic parameter extraction.

* Added writing variables.

* Add an interface test.

* Fix toArray.

* Support for extensions, and inheritance.

* Disable the doc test.

* Added flags to compileStdLib.

* More work around handling generics in markdown output.

* More improvements around associated type handling.

* List method names only once.
Output in/out/inout/const

* Fix namespace printing.

* WIP summarizing doc output.

* Small fixes and improvements for doc output.

* Output all stdlib in single doc file.

* Remove compile flags from addBuiltinSource.

* Find only unique signatures.
First pass at trying to get requirements.

* First pass at requirements for stdlib docs.

* Remove __ function/methods

* Added Target Availability

* Add markup access.
Make sections of stdlib hidden.

* MarkdownAccess -> Visibility
Add isVisible methods
Use ASTPrinter to print decl name.

* Add current stdlib doc output.

* Disable doc test for now.

* Fix clang issue.

* Don't use bullets and numbering , just use numbering.

* Put methods in source order.

* Fix bad-operator-call.slang test that fails because it now outputs out parameters as such.

* Refactor MarkDownWriter to separate 'extraction' from output.

* Fix typo around @ lines.

* Fix issue with extracting 'before' when preceeded by complex attributes/modifiers.

* Fix handling of generics with the same name.

* Work around for having overloading with generics - we don't want to output generic params as part of name.

* Remove generic paramters from name.

* Simplify handling of outputting overridable names.

16 files changed, 42219 insertions, 265 deletions

diff --git a/docs/stdlib-doc.md b/docs/stdlib-doc.md
new file mode 100644
index 000000000..2ac5f74e5
--- /dev/null
+++ b/docs/stdlib-doc.md
@@ -0,0 +1,40938 @@
+--------------------------------------------------------------------------------
+# `__BuiltinArithmeticType.init`
+
+## Signature 
+
+```
+__BuiltinArithmeticType.init(int value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `__BuiltinFloatingPointType.init`
+
+## Signature 
+
+```
+__BuiltinFloatingPointType.init(float value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `__BuiltinFloatingPointType.getPi`
+
+## Description
+
+Get the value of the mathematical constant pi in this type.
+
+## Signature 
+
+```
+__BuiltinFloatingPointType.This __BuiltinFloatingPointType.getPi();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `struct ConstantBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+
+--------------------------------------------------------------------------------
+# `struct TextureBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+
+--------------------------------------------------------------------------------
+# `struct ParameterBlock<T>`
+
+## Generic Parameters
+
+* `T`
+
+--------------------------------------------------------------------------------
+# `struct SamplerState`
+
+## Description
+
+Sampling state for filtered texture fetches.
+
+
+--------------------------------------------------------------------------------
+# `struct SamplerComparisonState`
+
+## Description
+
+Sampling state for filtered texture fetches that include a comparison operation before filtering.
+
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture1D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture1D<T>.init`
+
+## Signature 
+
+```
+SamplerTexture1D<T>.init(
+    Texture1D            t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture1D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture1D<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture1D<T>.init(
+    RWTexture1D          t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture1D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture1D<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture1D<T>.init(
+    RasterizerOrderedTexture1D t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture1DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture1DMS<T>.init`
+
+## Signature 
+
+```
+SamplerTexture1DMS<T>.init(
+    Texture1DMS          t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture1DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture1DMS<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture1DMS<T>.init(
+    RWTexture1DMS        t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture1DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture1DMS<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture1DMS<T>.init(
+    RasterizerOrderedTexture1DMS t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture1DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture1DArray<T>.init`
+
+## Signature 
+
+```
+SamplerTexture1DArray<T>.init(
+    Texture1DArray       t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture1DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture1DArray<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture1DArray<T>.init(
+    RWTexture1DArray     t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture1DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture1DArray<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture1DArray<T>.init(
+    RasterizerOrderedTexture1DArray t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture1DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture1DMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerTexture1DMSArray<T>.init(
+    Texture1DMSArray     t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture1DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture1DMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture1DMSArray<T>.init(
+    RWTexture1DMSArray   t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture1DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture1DMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture1DMSArray<T>.init(
+    RasterizerOrderedTexture1DMSArray t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture2D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture2D<T>.init`
+
+## Signature 
+
+```
+SamplerTexture2D<T>.init(
+    Texture2D            t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture2D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture2D<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture2D<T>.init(
+    RWTexture2D          t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture2D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture2D<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture2D<T>.init(
+    RasterizerOrderedTexture2D t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture2DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture2DMS<T>.init`
+
+## Signature 
+
+```
+SamplerTexture2DMS<T>.init(
+    Texture2DMS          t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture2DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture2DMS<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture2DMS<T>.init(
+    RWTexture2DMS        t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture2DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture2DMS<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture2DMS<T>.init(
+    RasterizerOrderedTexture2DMS t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture2DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture2DArray<T>.init`
+
+## Signature 
+
+```
+SamplerTexture2DArray<T>.init(
+    Texture2DArray       t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture2DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture2DArray<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture2DArray<T>.init(
+    RWTexture2DArray     t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture2DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture2DArray<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture2DArray<T>.init(
+    RasterizerOrderedTexture2DArray t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture2DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture2DMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerTexture2DMSArray<T>.init(
+    Texture2DMSArray     t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture2DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture2DMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture2DMSArray<T>.init(
+    RWTexture2DMSArray   t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture2DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture2DMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture2DMSArray<T>.init(
+    RasterizerOrderedTexture2DMSArray t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture3D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture3D<T>.init`
+
+## Signature 
+
+```
+SamplerTexture3D<T>.init(
+    Texture3D            t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture3D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture3D<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture3D<T>.init(
+    RWTexture3D          t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture3D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture3D<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture3D<T>.init(
+    RasterizerOrderedTexture3D t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTexture3DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTexture3DMS<T>.init`
+
+## Signature 
+
+```
+SamplerTexture3DMS<T>.init(
+    Texture3DMS          t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRWTexture3DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRWTexture3DMS<T>.init`
+
+## Signature 
+
+```
+SamplerRWTexture3DMS<T>.init(
+    RWTexture3DMS        t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTexture3DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTexture3DMS<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTexture3DMS<T>.init(
+    RasterizerOrderedTexture3DMS t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTextureCube<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTextureCube<T>.init`
+
+## Signature 
+
+```
+SamplerTextureCube<T>.init(
+    TextureCube          t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTextureCube<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTextureCube<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTextureCube<T>.init(
+    RasterizerOrderedTextureCube t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTextureCubeMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTextureCubeMS<T>.init`
+
+## Signature 
+
+```
+SamplerTextureCubeMS<T>.init(
+    TextureCubeMS        t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTextureCubeMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTextureCubeMS<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTextureCubeMS<T>.init(
+    RasterizerOrderedTextureCubeMS t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTextureCubeArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTextureCubeArray<T>.init`
+
+## Signature 
+
+```
+SamplerTextureCubeArray<T>.init(
+    TextureCubeArray     t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTextureCubeArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTextureCubeArray<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTextureCubeArray<T>.init(
+    RasterizerOrderedTextureCubeArray t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerTextureCubeMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerTextureCubeMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerTextureCubeMSArray<T>.init(
+    TextureCubeMSArray   t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct SamplerRasterizerOrderedTextureCubeMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `init`
+
+--------------------------------------------------------------------------------
+# `SamplerRasterizerOrderedTextureCubeMSArray<T>.init`
+
+## Signature 
+
+```
+SamplerRasterizerOrderedTextureCubeMSArray<T>.init(
+    RasterizerOrderedTextureCubeMSArray t,
+    SamplerState         s);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+* `s`
+
+--------------------------------------------------------------------------------
+# `texture`
+
+## Signature 
+
+```
+T texture<T>(
+    SamplerTexture1D     t,
+    vector<float,1>      location);
+T texture<T>(
+    SamplerRWTexture1D   t,
+    vector<float,1>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture1D t,
+    vector<float,1>      location);
+T texture<T>(
+    SamplerTexture1DMS   t,
+    vector<float,1>      location);
+T texture<T>(
+    SamplerRWTexture1DMS t,
+    vector<float,1>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture1DMS t,
+    vector<float,1>      location);
+T texture<T>(
+    SamplerTexture1DArray t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRWTexture1DArray t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture1DArray t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerTexture1DMSArray t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRWTexture1DMSArray t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture1DMSArray t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerTexture2D     t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRWTexture2D   t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture2D t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerTexture2DMS   t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRWTexture2DMS t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture2DMS t,
+    vector<float,2>      location);
+T texture<T>(
+    SamplerTexture2DArray t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRWTexture2DArray t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture2DArray t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerTexture2DMSArray t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRWTexture2DMSArray t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture2DMSArray t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerTexture3D     t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRWTexture3D   t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture3D t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerTexture3DMS   t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRWTexture3DMS t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTexture3DMS t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerTextureCube   t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTextureCube t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerTextureCubeMS t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTextureCubeMS t,
+    vector<float,3>      location);
+T texture<T>(
+    SamplerTextureCubeArray t,
+    vector<float,4>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTextureCubeArray t,
+    vector<float,4>      location);
+T texture<T>(
+    SamplerTextureCubeMSArray t,
+    vector<float,4>      location);
+T texture<T>(
+    SamplerRasterizerOrderedTextureCubeMSArray t,
+    vector<float,4>      location);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `t`
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct Texture1D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float Texture1D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float Texture1D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture1D<T>.GetDimensions(out uint width);
+void Texture1D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             numberOfLevels);
+void Texture1D<T>.GetDimensions(out float width);
+void Texture1D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1D<T>.Load(vector<int,2> location);
+/// See Target Availability 2
+T Texture1D<T>.Load(
+    vector<int,2>        location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T Texture1D<T>.Load(
+    vector<int,2>        location,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.subscript`
+
+## Signature 
+
+```
+T Texture1D<T>.subscript(uint location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location);
+/// See Target Availability 2
+T Texture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T Texture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    float                clamp);
+T Texture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.SampleBias`
+
+## Signature 
+
+```
+T Texture1D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                bias);
+T Texture1D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                bias,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.SampleCmp`
+
+## Signature 
+
+```
+float Texture1D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue);
+float Texture1D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float Texture1D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue);
+/// See Target Availability 2
+float Texture1D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.SampleGrad`
+
+## Signature 
+
+```
+T Texture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY);
+T Texture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset);
+T Texture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `Texture1D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                level);
+/// See Target Availability 2
+T Texture1D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                level,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension Texture1D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture1D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RWTexture1D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RWTexture1D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture1D<T>.GetDimensions(out uint width);
+void RWTexture1D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             numberOfLevels);
+void RWTexture1D<T>.GetDimensions(out float width);
+void RWTexture1D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1D<T>.Load(vector<int,1> location);
+/// See Target Availability 2
+T RWTexture1D<T>.Load(
+    vector<int,1>        location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T RWTexture1D<T>.Load(
+    vector<int,1>        location,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture1D<T>.subscript(uint location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location);
+/// See Target Availability 2
+T RWTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T RWTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    float                clamp);
+T RWTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.SampleBias`
+
+## Signature 
+
+```
+T RWTexture1D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                bias);
+T RWTexture1D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                bias,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.SampleCmp`
+
+## Signature 
+
+```
+float RWTexture1D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue);
+float RWTexture1D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RWTexture1D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RWTexture1D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.SampleGrad`
+
+## Signature 
+
+```
+T RWTexture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY);
+T RWTexture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset);
+T RWTexture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                level);
+/// See Target Availability 2
+T RWTexture1D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                level,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture1D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture1D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture1D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture1D<T>.GetDimensions(out uint width);
+void RasterizerOrderedTexture1D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture1D<T>.GetDimensions(out float width);
+void RasterizerOrderedTexture1D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1D<T>.Load(vector<int,1> location);
+T RasterizerOrderedTexture1D<T>.Load(
+    vector<int,1>        location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture1D<T>.Load(
+    vector<int,1>        location,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1D<T>.subscript(uint location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location);
+/// See Target Availability 2
+T RasterizerOrderedTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T RasterizerOrderedTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    float                clamp);
+T RasterizerOrderedTexture1D<T>.Sample(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.SampleBias`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                bias);
+T RasterizerOrderedTexture1D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                bias,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.SampleCmp`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture1D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue);
+float RasterizerOrderedTexture1D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RasterizerOrderedTexture1D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RasterizerOrderedTexture1D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,1>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.SampleGrad`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY);
+T RasterizerOrderedTexture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset);
+T RasterizerOrderedTexture1D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                level);
+/// See Target Availability 2
+T RasterizerOrderedTexture1D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,1>      location,
+    float                level,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.Gather(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherRed(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherGreen(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherBlue(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location);
+vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1D.GatherAlpha(
+    SamplerState         s,
+    vector<float,1>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct Texture1DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `Texture1DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture1DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             sampleCount);
+void Texture1DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void Texture1DMS<T>.GetDimensions(
+    out float            width,
+    out float            sampleCount);
+void Texture1DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture1DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> Texture1DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `Texture1DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex);
+T Texture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T Texture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture1DMS<T>.subscript`
+
+## Signature 
+
+```
+T Texture1DMS<T>.subscript(uint location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture1DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture1DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             sampleCount);
+void RWTexture1DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RWTexture1DMS<T>.GetDimensions(
+    out float            width,
+    out float            sampleCount);
+void RWTexture1DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RWTexture1DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex);
+T RWTexture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T RWTexture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMS<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture1DMS<T>.subscript(uint location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture1DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture1DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             sampleCount);
+void RasterizerOrderedTexture1DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture1DMS<T>.GetDimensions(
+    out float            width,
+    out float            sampleCount);
+void RasterizerOrderedTexture1DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RasterizerOrderedTexture1DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex);
+T RasterizerOrderedTexture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture1DMS<T>.Load(
+    vector<int,1>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMS<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1DMS<T>.subscript(uint location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct Texture1DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float Texture1DArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float Texture1DArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture1DArray<T>.GetDimensions(
+    out uint             width,
+    out uint             elements);
+void Texture1DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             elements,
+    out uint             numberOfLevels);
+void Texture1DArray<T>.GetDimensions(
+    out float            width,
+    out float            elements);
+void Texture1DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1DArray<T>.Load(vector<int,3> location);
+T Texture1DArray<T>.Load(
+    vector<int,3>        location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T Texture1DArray<T>.Load(
+    vector<int,3>        location,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.subscript`
+
+## Signature 
+
+```
+T Texture1DArray<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+T Texture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T Texture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    float                clamp);
+T Texture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.SampleBias`
+
+## Signature 
+
+```
+T Texture1DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias);
+T Texture1DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.SampleCmp`
+
+## Signature 
+
+```
+float Texture1DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+float Texture1DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float Texture1DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+/// See Target Availability 2
+float Texture1DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T Texture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY);
+T Texture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset);
+T Texture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level);
+/// See Target Availability 2
+T Texture1DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension Texture1DArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture1DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RWTexture1DArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RWTexture1DArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture1DArray<T>.GetDimensions(
+    out uint             width,
+    out uint             elements);
+void RWTexture1DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             elements,
+    out uint             numberOfLevels);
+void RWTexture1DArray<T>.GetDimensions(
+    out float            width,
+    out float            elements);
+void RWTexture1DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1DArray<T>.Load(vector<int,2> location);
+/// See Target Availability 2
+T RWTexture1DArray<T>.Load(
+    vector<int,2>        location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T RWTexture1DArray<T>.Load(
+    vector<int,2>        location,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture1DArray<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+T RWTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T RWTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    float                clamp);
+T RWTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.SampleBias`
+
+## Signature 
+
+```
+T RWTexture1DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias);
+T RWTexture1DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.SampleCmp`
+
+## Signature 
+
+```
+float RWTexture1DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+float RWTexture1DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RWTexture1DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RWTexture1DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T RWTexture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY);
+T RWTexture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset);
+T RWTexture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level);
+/// See Target Availability 2
+T RWTexture1DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1DArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture1DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture1DArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,1>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture1DArray<T>.GetDimensions(
+    out uint             width,
+    out uint             elements);
+void RasterizerOrderedTexture1DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             elements,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture1DArray<T>.GetDimensions(
+    out float            width,
+    out float            elements);
+void RasterizerOrderedTexture1DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1DArray<T>.Load(vector<int,2> location);
+T RasterizerOrderedTexture1DArray<T>.Load(
+    vector<int,2>        location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture1DArray<T>.Load(
+    vector<int,2>        location,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1DArray<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+T RasterizerOrderedTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 3
+T RasterizerOrderedTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    float                clamp);
+T RasterizerOrderedTexture1DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.SampleBias`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias);
+T RasterizerOrderedTexture1DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.SampleCmp`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture1DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+float RasterizerOrderedTexture1DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RasterizerOrderedTexture1DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RasterizerOrderedTexture1DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY);
+T RasterizerOrderedTexture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset);
+T RasterizerOrderedTexture1DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,1>      gradX,
+    vector<float,1>      gradY,
+    vector<int,1>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level);
+/// See Target Availability 2
+T RasterizerOrderedTexture1DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level,
+    vector<int,1>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1DArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture1DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture1DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,1>        offset1,
+    vector<int,1>        offset2,
+    vector<int,1>        offset3,
+    vector<int,1>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct Texture1DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `Texture1DMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture1DMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             elements,
+    out uint             sampleCount);
+void Texture1DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void Texture1DMSArray<T>.GetDimensions(
+    out float            width,
+    out float            elements,
+    out float            sampleCount);
+void Texture1DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture1DMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> Texture1DMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `Texture1DMSArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex);
+T Texture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T Texture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture1DMSArray<T>.subscript`
+
+## Signature 
+
+```
+T Texture1DMSArray<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture1DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture1DMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             elements,
+    out uint             sampleCount);
+void RWTexture1DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RWTexture1DMSArray<T>.GetDimensions(
+    out float            width,
+    out float            elements,
+    out float            sampleCount);
+void RWTexture1DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RWTexture1DMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMSArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex);
+T RWTexture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T RWTexture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture1DMSArray<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture1DMSArray<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture1DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             elements,
+    out uint             sampleCount);
+void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
+    out float            width,
+    out float            elements,
+    out float            sampleCount);
+void RasterizerOrderedTexture1DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RasterizerOrderedTexture1DMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMSArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex);
+T RasterizerOrderedTexture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture1DMSArray<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,1>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture1DMSArray<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture1DMSArray<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct Texture2D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float Texture2D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float Texture2D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture2D<T>.GetDimensions(
+    out uint             width,
+    out uint             height);
+void Texture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             numberOfLevels);
+void Texture2D<T>.GetDimensions(
+    out float            width,
+    out float            height);
+void Texture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2D<T>.Load(vector<int,3> location);
+T Texture2D<T>.Load(
+    vector<int,3>        location,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T Texture2D<T>.Load(
+    vector<int,3>        location,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.subscript`
+
+## Signature 
+
+```
+T Texture2D<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+T Texture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T Texture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    float                clamp);
+T Texture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.SampleBias`
+
+## Signature 
+
+```
+T Texture2D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias);
+T Texture2D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.SampleCmp`
+
+## Signature 
+
+```
+float Texture2D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+float Texture2D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float Texture2D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+/// See Target Availability 2
+float Texture2D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.SampleGrad`
+
+## Signature 
+
+```
+T Texture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY);
+T Texture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset);
+T Texture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `Texture2D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level);
+/// See Target Availability 2
+T Texture2D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension Texture2D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture2D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RWTexture2D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RWTexture2D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture2D<T>.GetDimensions(
+    out uint             width,
+    out uint             height);
+void RWTexture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             numberOfLevels);
+void RWTexture2D<T>.GetDimensions(
+    out float            width,
+    out float            height);
+void RWTexture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2D<T>.Load(vector<int,2> location);
+/// See Target Availability 2
+T RWTexture2D<T>.Load(
+    vector<int,2>        location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T RWTexture2D<T>.Load(
+    vector<int,2>        location,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture2D<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+T RWTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T RWTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    float                clamp);
+T RWTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.SampleBias`
+
+## Signature 
+
+```
+T RWTexture2D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias);
+T RWTexture2D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.SampleCmp`
+
+## Signature 
+
+```
+float RWTexture2D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+float RWTexture2D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RWTexture2D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RWTexture2D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.SampleGrad`
+
+## Signature 
+
+```
+T RWTexture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY);
+T RWTexture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset);
+T RWTexture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level);
+/// See Target Availability 2
+T RWTexture2D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture2D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture2D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture2D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture2D<T>.GetDimensions(
+    out uint             width,
+    out uint             height);
+void RasterizerOrderedTexture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture2D<T>.GetDimensions(
+    out float            width,
+    out float            height);
+void RasterizerOrderedTexture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2D<T>.Load(vector<int,2> location);
+T RasterizerOrderedTexture2D<T>.Load(
+    vector<int,2>        location,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture2D<T>.Load(
+    vector<int,2>        location,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2D<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+T RasterizerOrderedTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T RasterizerOrderedTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    float                clamp);
+T RasterizerOrderedTexture2D<T>.Sample(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.SampleBias`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias);
+T RasterizerOrderedTexture2D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                bias,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.SampleCmp`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture2D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+float RasterizerOrderedTexture2D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RasterizerOrderedTexture2D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RasterizerOrderedTexture2D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,2>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.SampleGrad`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY);
+T RasterizerOrderedTexture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset);
+T RasterizerOrderedTexture2D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level);
+/// See Target Availability 2
+T RasterizerOrderedTexture2D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,2>      location,
+    float                level,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.Gather(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherRed(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherGreen(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherBlue(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2D.GatherAlpha(
+    SamplerState         s,
+    vector<float,2>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct Texture2DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `Texture2DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture2DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount);
+void Texture2DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void Texture2DMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            sampleCount);
+void Texture2DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture2DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> Texture2DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `Texture2DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex);
+T Texture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T Texture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture2DMS<T>.subscript`
+
+## Signature 
+
+```
+T Texture2DMS<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture2DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture2DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount);
+void RWTexture2DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RWTexture2DMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            sampleCount);
+void RWTexture2DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RWTexture2DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex);
+T RWTexture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T RWTexture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMS<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture2DMS<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture2DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture2DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount);
+void RasterizerOrderedTexture2DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture2DMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            sampleCount);
+void RasterizerOrderedTexture2DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RasterizerOrderedTexture2DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex);
+T RasterizerOrderedTexture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture2DMS<T>.Load(
+    vector<int,2>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMS<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2DMS<T>.subscript(vector<uint,2> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct Texture2DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float Texture2DArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float Texture2DArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture2DArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements);
+void Texture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             numberOfLevels);
+void Texture2DArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements);
+void Texture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2DArray<T>.Load(vector<int,4> location);
+T Texture2DArray<T>.Load(
+    vector<int,4>        location,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T Texture2DArray<T>.Load(
+    vector<int,4>        location,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.subscript`
+
+## Signature 
+
+```
+T Texture2DArray<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T Texture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T Texture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    float                clamp);
+T Texture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.SampleBias`
+
+## Signature 
+
+```
+T Texture2DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+T Texture2DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.SampleCmp`
+
+## Signature 
+
+```
+float Texture2DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+float Texture2DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float Texture2DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+/// See Target Availability 2
+float Texture2DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T Texture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY);
+T Texture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset);
+T Texture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+/// See Target Availability 2
+T Texture2DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension Texture2DArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> Texture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture2DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RWTexture2DArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RWTexture2DArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture2DArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements);
+void RWTexture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             numberOfLevels);
+void RWTexture2DArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements);
+void RWTexture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2DArray<T>.Load(vector<int,3> location);
+/// See Target Availability 2
+T RWTexture2DArray<T>.Load(
+    vector<int,3>        location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T RWTexture2DArray<T>.Load(
+    vector<int,3>        location,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture2DArray<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T RWTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T RWTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    float                clamp);
+T RWTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.SampleBias`
+
+## Signature 
+
+```
+T RWTexture2DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+T RWTexture2DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.SampleCmp`
+
+## Signature 
+
+```
+float RWTexture2DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+float RWTexture2DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RWTexture2DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RWTexture2DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T RWTexture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY);
+T RWTexture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset);
+T RWTexture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+/// See Target Availability 2
+T RWTexture2DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2DArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RWTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture2DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture2DArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture2DArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements);
+void RasterizerOrderedTexture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture2DArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements);
+void RasterizerOrderedTexture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2DArray<T>.Load(vector<int,3> location);
+T RasterizerOrderedTexture2DArray<T>.Load(
+    vector<int,3>        location,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture2DArray<T>.Load(
+    vector<int,3>        location,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2DArray<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T RasterizerOrderedTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+T RasterizerOrderedTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    float                clamp);
+T RasterizerOrderedTexture2DArray<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.SampleBias`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+T RasterizerOrderedTexture2DArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.SampleCmp`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture2DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+float RasterizerOrderedTexture2DArray<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RasterizerOrderedTexture2DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RasterizerOrderedTexture2DArray<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY);
+T RasterizerOrderedTexture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset);
+T RasterizerOrderedTexture2DArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,2>      gradX,
+    vector<float,2>      gradY,
+    vector<int,2>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+/// See Target Availability 2
+T RasterizerOrderedTexture2DArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2DArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<T,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<float,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<int,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture2DArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset,
+    out uint             status);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4);
+/// See Target Availability 3
+vector<uint,4> RasterizerOrderedTexture2DArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,2>        offset1,
+    vector<int,2>        offset2,
+    vector<int,2>        offset3,
+    vector<int,2>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct Texture2DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `Texture2DMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture2DMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount);
+void Texture2DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void Texture2DMSArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount);
+void Texture2DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture2DMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> Texture2DMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `Texture2DMSArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T Texture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T Texture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture2DMSArray<T>.subscript`
+
+## Signature 
+
+```
+T Texture2DMSArray<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture2DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture2DMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount);
+void RWTexture2DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RWTexture2DMSArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount);
+void RWTexture2DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RWTexture2DMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMSArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T RWTexture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T RWTexture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture2DMSArray<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture2DMSArray<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture2DMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount);
+void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount);
+void RasterizerOrderedTexture2DMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RasterizerOrderedTexture2DMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMSArray<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T RasterizerOrderedTexture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture2DMSArray<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,2>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture2DMSArray<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture2DMSArray<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct Texture3D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float Texture3D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float Texture3D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture3D<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             depth);
+void Texture3D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             numberOfLevels);
+void Texture3D<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            depth);
+void Texture3D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `depth`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture3D<T>.Load(vector<int,4> location);
+T Texture3D<T>.Load(
+    vector<int,4>        location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T Texture3D<T>.Load(
+    vector<int,4>        location,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.subscript`
+
+## Signature 
+
+```
+T Texture3D<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T Texture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 3
+T Texture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    float                clamp);
+T Texture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.SampleBias`
+
+## Signature 
+
+```
+T Texture3D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+T Texture3D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.SampleCmp`
+
+## Signature 
+
+```
+float Texture3D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+float Texture3D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float Texture3D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+/// See Target Availability 2
+float Texture3D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.SampleGrad`
+
+## Signature 
+
+```
+T Texture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY);
+T Texture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY,
+    vector<int,3>        offset);
+T Texture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY,
+    vector<int,3>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `Texture3D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture3D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+/// See Target Availability 2
+T Texture3D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension Texture3D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension Texture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `Texture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `Texture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> Texture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture3D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RWTexture3D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RWTexture3D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture3D<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             depth);
+void RWTexture3D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             numberOfLevels);
+void RWTexture3D<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            depth);
+void RWTexture3D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `depth`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture3D<T>.Load(vector<int,3> location);
+/// See Target Availability 2
+T RWTexture3D<T>.Load(
+    vector<int,3>        location,
+    vector<int,3>        offset);
+/// See Target Availability 3
+T RWTexture3D<T>.Load(
+    vector<int,3>        location,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture3D<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T RWTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 3
+T RWTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    float                clamp);
+T RWTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.SampleBias`
+
+## Signature 
+
+```
+T RWTexture3D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+T RWTexture3D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.SampleCmp`
+
+## Signature 
+
+```
+float RWTexture3D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+float RWTexture3D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RWTexture3D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RWTexture3D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.SampleGrad`
+
+## Signature 
+
+```
+T RWTexture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY);
+T RWTexture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY,
+    vector<int,3>        offset);
+T RWTexture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY,
+    vector<int,3>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture3D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+/// See Target Availability 2
+T RWTexture3D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture3D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RWTexture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RWTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RWTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture3D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `subscript`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture3D<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture3D<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture3D<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             depth);
+void RasterizerOrderedTexture3D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture3D<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            depth);
+void RasterizerOrderedTexture3D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `depth`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture3D<T>.Load(vector<int,3> location);
+T RasterizerOrderedTexture3D<T>.Load(
+    vector<int,3>        location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture3D<T>.Load(
+    vector<int,3>        location,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture3D<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T RasterizerOrderedTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 3
+T RasterizerOrderedTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    float                clamp);
+T RasterizerOrderedTexture3D<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.SampleBias`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture3D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+T RasterizerOrderedTexture3D<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.SampleCmp`
+
+## Signature 
+
+```
+float RasterizerOrderedTexture3D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+float RasterizerOrderedTexture3D<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float RasterizerOrderedTexture3D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+/// See Target Availability 2
+float RasterizerOrderedTexture3D<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.SampleGrad`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY);
+T RasterizerOrderedTexture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY,
+    vector<int,3>        offset);
+T RasterizerOrderedTexture3D<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY,
+    vector<int,3>        offset,
+    float                lodClamp);
+```
+
+## Requirements
+
+`GLSL GL_ARB_sparse_texture_clamp`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+* `offset`
+* `lodClamp`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D<T>.SampleLevel`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture3D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+/// See Target Availability 2
+T RasterizerOrderedTexture3D<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level,
+    vector<int,3>        offset);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture3D`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTexture3D`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3D.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTexture3D.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct Texture3DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `Texture3DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void Texture3DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             sampleCount);
+void Texture3DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void Texture3DMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            sampleCount);
+void Texture3DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `depth`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `Texture3DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> Texture3DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `Texture3DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Texture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T Texture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T Texture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Texture3DMS<T>.subscript`
+
+## Signature 
+
+```
+T Texture3DMS<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RWTexture3DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RWTexture3DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWTexture3DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             sampleCount);
+void RWTexture3DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RWTexture3DMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            sampleCount);
+void RWTexture3DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `depth`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RWTexture3DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RWTexture3DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RWTexture3DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWTexture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T RWTexture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T RWTexture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWTexture3DMS<T>.subscript`
+
+## Signature 
+
+```
+T RWTexture3DMS<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTexture3DMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3DMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTexture3DMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             sampleCount);
+void RasterizerOrderedTexture3DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             depth,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RasterizerOrderedTexture3DMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            sampleCount);
+void RasterizerOrderedTexture3DMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            depth,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `depth`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3DMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RasterizerOrderedTexture3DMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3DMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTexture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T RasterizerOrderedTexture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTexture3DMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTexture3DMS<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedTexture3DMS<T>.subscript(vector<uint,3> location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `location`
+
+--------------------------------------------------------------------------------
+# `struct TextureCube<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float TextureCube<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float TextureCube<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.GetDimensions`
+
+## Signature 
+
+```
+void TextureCube<T>.GetDimensions(
+    out uint             width,
+    out uint             height);
+void TextureCube<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             numberOfLevels);
+void TextureCube<T>.GetDimensions(
+    out float            width,
+    out float            height);
+void TextureCube<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T TextureCube<T>.Load(vector<int,4> location);
+T TextureCube<T>.Load(
+    vector<int,4>        location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T TextureCube<T>.Load(
+    vector<int,4>        location,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T TextureCube<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T TextureCube<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                clamp);
+T TextureCube<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.SampleBias`
+
+## Signature 
+
+```
+T TextureCube<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.SampleCmp`
+
+## Signature 
+
+```
+float TextureCube<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+float TextureCube<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.SampleGrad`
+
+## Signature 
+
+```
+T TextureCube<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+
+--------------------------------------------------------------------------------
+# `TextureCube<T>.SampleLevel`
+
+## Signature 
+
+```
+T TextureCube<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+
+--------------------------------------------------------------------------------
+# `extension TextureCube`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension TextureCube`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension TextureCube`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension TextureCube`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTextureCube<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Load`
+* `Sample`
+* `SampleBias`
+* `SampleCmp`
+* `SampleCmpLevelZero`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RasterizerOrderedTextureCube<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RasterizerOrderedTextureCube<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTextureCube<T>.GetDimensions(
+    out uint             width,
+    out uint             height);
+void RasterizerOrderedTextureCube<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             numberOfLevels);
+void RasterizerOrderedTextureCube<T>.GetDimensions(
+    out float            width,
+    out float            height);
+void RasterizerOrderedTextureCube<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTextureCube<T>.Load(vector<int,3> location);
+T RasterizerOrderedTextureCube<T>.Load(
+    vector<int,3>        location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTextureCube<T>.Load(
+    vector<int,3>        location,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTextureCube<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location);
+/// See Target Availability 2
+T RasterizerOrderedTextureCube<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                clamp);
+T RasterizerOrderedTextureCube<T>.Sample(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.SampleBias`
+
+## Signature 
+
+```
+T RasterizerOrderedTextureCube<T>.SampleBias(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                bias);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.SampleCmp`
+
+## Signature 
+
+```
+float RasterizerOrderedTextureCube<T>.SampleCmp(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.SampleCmpLevelZero`
+
+## Signature 
+
+```
+float RasterizerOrderedTextureCube<T>.SampleCmpLevelZero(
+    SamplerComparisonState s,
+    vector<float,3>      location,
+    float                compareValue);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `compareValue`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.SampleGrad`
+
+## Signature 
+
+```
+T RasterizerOrderedTextureCube<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube<T>.SampleLevel`
+
+## Signature 
+
+```
+T RasterizerOrderedTextureCube<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,3>      location,
+    float                level);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCube`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCube`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCube`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCube`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.Gather(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherRed(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherGreen(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherBlue(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCube.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location);
+vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCube.GatherAlpha(
+    SamplerState         s,
+    vector<float,3>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct TextureCubeMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+
+--------------------------------------------------------------------------------
+# `TextureCubeMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void TextureCubeMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount);
+void TextureCubeMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void TextureCubeMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            sampleCount);
+void TextureCubeMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `TextureCubeMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> TextureCubeMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `TextureCubeMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T TextureCubeMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T TextureCubeMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T TextureCubeMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTextureCubeMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+* `Load`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeMS<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount);
+void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            sampleCount);
+void RasterizerOrderedTextureCubeMS<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeMS<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RasterizerOrderedTextureCubeMS<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeMS<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTextureCubeMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex);
+T RasterizerOrderedTextureCubeMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset);
+/// See Target Availability 2
+T RasterizerOrderedTextureCubeMS<T>.Load(
+    vector<int,3>        location,
+    int                  sampleIndex,
+    vector<int,3>        offset,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `sampleIndex`
+* `offset`
+* `status`
+
+--------------------------------------------------------------------------------
+# `struct TextureCubeArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Sample`
+* `SampleBias`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float TextureCubeArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float TextureCubeArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void TextureCubeArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements);
+void TextureCubeArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             numberOfLevels);
+void TextureCubeArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements);
+void TextureCubeArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T TextureCubeArray<T>.Sample(
+    SamplerState         s,
+    vector<float,4>      location);
+/// See Target Availability 2
+T TextureCubeArray<T>.Sample(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                clamp);
+T TextureCubeArray<T>.Sample(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray<T>.SampleBias`
+
+## Signature 
+
+```
+T TextureCubeArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                bias);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T TextureCubeArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray<T>.SampleLevel`
+
+## Signature 
+
+```
+T TextureCubeArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                level);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+
+--------------------------------------------------------------------------------
+# `extension TextureCubeArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension TextureCubeArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension TextureCubeArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension TextureCubeArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `TextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> TextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTextureCubeArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `CalculateLevelOfDetail`
+* `CalculateLevelOfDetailUnclamped`
+* `GetDimensions`
+* `Sample`
+* `SampleBias`
+* `SampleGrad`
+* `SampleLevel`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetail`
+
+## Signature 
+
+```
+float RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetail(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetailUnclamped`
+
+## Signature 
+
+```
+float RasterizerOrderedTextureCubeArray<T>.CalculateLevelOfDetailUnclamped(
+    SamplerState         s,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements);
+void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             numberOfLevels);
+void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements);
+void RasterizerOrderedTextureCubeArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray<T>.Sample`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedTextureCubeArray<T>.Sample(
+    SamplerState         s,
+    vector<float,4>      location);
+/// See Target Availability 2
+T RasterizerOrderedTextureCubeArray<T>.Sample(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                clamp);
+T RasterizerOrderedTextureCubeArray<T>.Sample(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                clamp,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `clamp`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray<T>.SampleBias`
+
+## Signature 
+
+```
+T RasterizerOrderedTextureCubeArray<T>.SampleBias(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                bias);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `bias`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray<T>.SampleGrad`
+
+## Signature 
+
+```
+T RasterizerOrderedTextureCubeArray<T>.SampleGrad(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<float,3>      gradX,
+    vector<float,3>      gradY);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `gradX`
+* `gradY`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray<T>.SampleLevel`
+
+## Signature 
+
+```
+T RasterizerOrderedTextureCubeArray<T>.SampleLevel(
+    SamplerState         s,
+    vector<float,4>      location,
+    float                level);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `level`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCubeArray`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<T,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCubeArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<float,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCubeArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<int,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `extension RasterizerOrderedTextureCubeArray`
+
+## Methods
+
+* `Gather`
+* `GatherRed`
+* `GatherGreen`
+* `GatherBlue`
+* `GatherAlpha`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.Gather`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.Gather(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherRed`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherRed(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherGreen`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherGreen(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherBlue`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherBlue(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeArray.GatherAlpha`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location);
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset,
+    out uint             status);
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedTextureCubeArray.GatherAlpha(
+    SamplerState         s,
+    vector<float,4>      location,
+    vector<int,3>        offset1,
+    vector<int,3>        offset2,
+    vector<int,3>        offset3,
+    vector<int,3>        offset4,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `s`
+* `location`
+* `offset`
+* `status`
+* `offset1`
+* `offset2`
+* `offset3`
+* `offset4`
+
+--------------------------------------------------------------------------------
+# `struct TextureCubeMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+
+--------------------------------------------------------------------------------
+# `TextureCubeMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void TextureCubeMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount);
+void TextureCubeMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void TextureCubeMSArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount);
+void TextureCubeMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `TextureCubeMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> TextureCubeMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedTextureCubeMSArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `GetSamplePosition`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeMSArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount);
+void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             sampleCount,
+    out uint             numberOfLevels);
+void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount);
+void RasterizerOrderedTextureCubeMSArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            sampleCount,
+    out float            numberOfLevels);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `sampleCount`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedTextureCubeMSArray<T>.GetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> RasterizerOrderedTextureCubeMSArray<T>.GetSamplePosition(int s);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `s`
+
+--------------------------------------------------------------------------------
+# `bit_cast`
+
+## Signature 
+
+```
+T bit_cast<T, U>(U value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `U`
+* `value`
+
+--------------------------------------------------------------------------------
+# `getStringHash`
+
+## Description
+
+Given a string returns an integer hash of that string.
+
+## Signature 
+
+```
+int getStringHash(String string);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `string`
+
+--------------------------------------------------------------------------------
+# `beginInvocationInterlock`
+
+## Description
+
+Mark beginning of "interlocked" operations in a fragment shader.
+
+## Signature 
+
+```
+void beginInvocationInterlock();
+```
+
+## Requirements
+
+`GLSL GL_ARB_fragment_shader_interlock`, `GLSL420`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `endInvocationInterlock`
+
+## Description
+
+Mark end of "interlocked" operations in a fragment shader.
+
+## Signature 
+
+```
+void endInvocationInterlock();
+```
+
+## Requirements
+
+`GLSL GL_ARB_fragment_shader_interlock`, `GLSL420`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# enum _AttributeTargets
+
+## Values 
+
+* _Struct_
+* _Var_
+* _Function_
+--------------------------------------------------------------------------------
+# `struct AppendStructuredBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `Append`
+* `GetDimensions`
+
+--------------------------------------------------------------------------------
+# `AppendStructuredBuffer<T>.Append`
+
+## Signature 
+
+```
+void AppendStructuredBuffer<T>.Append(T value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `AppendStructuredBuffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void AppendStructuredBuffer<T>.GetDimensions(
+    out uint             numStructs,
+    out uint             stride);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `numStructs`
+* `stride`
+
+--------------------------------------------------------------------------------
+# `struct ByteAddressBuffer`
+
+## Methods
+
+* `GetDimensions`
+* `Load2`
+* `Load3`
+* `Load4`
+
+--------------------------------------------------------------------------------
+# `ByteAddressBuffer.GetDimensions`
+
+## Signature 
+
+```
+void ByteAddressBuffer.GetDimensions(out uint dim);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dim`
+
+--------------------------------------------------------------------------------
+# `ByteAddressBuffer.Load2`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,2> ByteAddressBuffer.Load2(int location);
+/// See Target Availability 2
+vector<uint,2> ByteAddressBuffer.Load2(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `ByteAddressBuffer.Load3`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,3> ByteAddressBuffer.Load3(int location);
+/// See Target Availability 2
+vector<uint,3> ByteAddressBuffer.Load3(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `ByteAddressBuffer.Load4`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> ByteAddressBuffer.Load4(int location);
+/// See Target Availability 2
+vector<uint,4> ByteAddressBuffer.Load4(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `ByteAddressBuffer.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+uint ByteAddressBuffer.Load(int location);
+/// See Target Availability 2
+uint ByteAddressBuffer.Load(
+    int                  location,
+    out uint             status);
+T ByteAddressBuffer.Load<T>(int location);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `struct StructuredBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `StructuredBuffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void StructuredBuffer<T>.GetDimensions(
+    out uint             numStructs,
+    out uint             stride);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `numStructs`
+* `stride`
+
+--------------------------------------------------------------------------------
+# `StructuredBuffer<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T StructuredBuffer<T>.Load(int location);
+/// See Target Availability 2
+T StructuredBuffer<T>.Load(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `StructuredBuffer<T>.subscript`
+
+## Signature 
+
+```
+T StructuredBuffer<T>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `struct ConsumeStructuredBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `Consume`
+* `GetDimensions`
+
+--------------------------------------------------------------------------------
+# `ConsumeStructuredBuffer<T>.Consume`
+
+## Signature 
+
+```
+T ConsumeStructuredBuffer<T>.Consume();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `ConsumeStructuredBuffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void ConsumeStructuredBuffer<T>.GetDimensions(
+    out uint             numStructs,
+    out uint             stride);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `numStructs`
+* `stride`
+
+--------------------------------------------------------------------------------
+# `struct InputPatch<T, N:int>`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `InputPatch<T, N:int>.subscript`
+
+## Signature 
+
+```
+T InputPatch<T, N:int>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `struct OutputPatch<T, N:int>`
+
+## Generic Parameters
+
+* `T`
+* `N`
+## Methods
+
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `OutputPatch<T, N:int>.subscript`
+
+## Signature 
+
+```
+T OutputPatch<T, N:int>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `struct RWByteAddressBuffer`
+
+## Methods
+
+* `GetDimensions`
+* `Load2`
+* `Load3`
+* `Load4`
+* `InterlockedAddF32`
+* `InterlockedAddI64`
+* `InterlockedCompareExchangeU64`
+* `InterlockedMaxU64`
+* `InterlockedMinU64`
+* `InterlockedAndU64`
+* `InterlockedOrU64`
+* `InterlockedXorU64`
+* `InterlockedExchangeU64`
+* `InterlockedAdd`
+* `InterlockedAnd`
+* `InterlockedCompareExchange`
+* `InterlockedCompareStore`
+* `InterlockedExchange`
+* `InterlockedMax`
+* `InterlockedMin`
+* `InterlockedOr`
+* `InterlockedXor`
+* `Store2`
+* `Store3`
+* `Store4`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.GetDimensions`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.GetDimensions(out uint dim);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dim`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Load2`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,2> RWByteAddressBuffer.Load2(int location);
+/// See Target Availability 2
+vector<uint,2> RWByteAddressBuffer.Load2(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Load3`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,3> RWByteAddressBuffer.Load3(int location);
+/// See Target Availability 2
+vector<uint,3> RWByteAddressBuffer.Load3(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Load4`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RWByteAddressBuffer.Load4(int location);
+/// See Target Availability 2
+vector<uint,4> RWByteAddressBuffer.Load4(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+uint RWByteAddressBuffer.Load(int location);
+/// See Target Availability 2
+uint RWByteAddressBuffer.Load(
+    int                  location,
+    out uint             status);
+T RWByteAddressBuffer.Load<T>(int location);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedAddF32`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedAddF32(
+    uint                 byteAddress,
+    float                valueToAdd,
+    out float            originalValue);
+void RWByteAddressBuffer.InterlockedAddF32(
+    uint                 byteAddress,
+    float                valueToAdd);
+```
+
+## Requirements
+
+`CUDA SM 2.0`, `NVAPI`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `valueToAdd`
+* `originalValue`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedAddI64`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedAddI64(
+    uint                 byteAddress,
+    int64_t              valueToAdd,
+    out int64_t          originalValue);
+void RWByteAddressBuffer.InterlockedAddI64(
+    uint                 byteAddress,
+    int64_t              valueToAdd);
+```
+
+## Requirements
+
+`CUDA SM 6.0`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `valueToAdd`
+* `originalValue`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedCompareExchangeU64`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedCompareExchangeU64(
+    uint                 byteAddress,
+    uint64_t             compareValue,
+    uint64_t             value,
+    out uint64_t         outOriginalValue);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `compareValue`
+* `value`
+* `outOriginalValue`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedMaxU64`
+
+## Signature 
+
+```
+uint64_t RWByteAddressBuffer.InterlockedMaxU64(
+    uint                 byteAddress,
+    uint64_t             value);
+```
+
+## Requirements
+
+`CUDA SM 3.5`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedMinU64`
+
+## Signature 
+
+```
+uint64_t RWByteAddressBuffer.InterlockedMinU64(
+    uint                 byteAddress,
+    uint64_t             value);
+```
+
+## Requirements
+
+`CUDA SM 3.5`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedAndU64`
+
+## Signature 
+
+```
+uint64_t RWByteAddressBuffer.InterlockedAndU64(
+    uint                 byteAddress,
+    uint64_t             value);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedOrU64`
+
+## Signature 
+
+```
+uint64_t RWByteAddressBuffer.InterlockedOrU64(
+    uint                 byteAddress,
+    uint64_t             value);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedXorU64`
+
+## Signature 
+
+```
+uint64_t RWByteAddressBuffer.InterlockedXorU64(
+    uint                 byteAddress,
+    uint64_t             value);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedExchangeU64`
+
+## Signature 
+
+```
+uint64_t RWByteAddressBuffer.InterlockedExchangeU64(
+    uint                 byteAddress,
+    uint64_t             value);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `byteAddress`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedAdd`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedAdd(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RWByteAddressBuffer.InterlockedAdd(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedAnd`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedAnd(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RWByteAddressBuffer.InterlockedAnd(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedCompareExchange`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedCompareExchange(
+    uint                 dest,
+    uint                 compare_value,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `compare_value`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedCompareStore`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedCompareStore(
+    uint                 dest,
+    uint                 compare_value,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `compare_value`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedExchange`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedExchange(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedMax`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedMax(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RWByteAddressBuffer.InterlockedMax(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedMin`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedMin(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RWByteAddressBuffer.InterlockedMin(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedOr`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedOr(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RWByteAddressBuffer.InterlockedOr(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.InterlockedXor`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.InterlockedXor(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RWByteAddressBuffer.InterlockedXor(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Store2`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.Store2(
+    uint                 address,
+    vector<uint,2>       value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `address`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Store3`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.Store3(
+    uint                 address,
+    vector<uint,3>       value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `address`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Store4`
+
+## Signature 
+
+```
+void RWByteAddressBuffer.Store4(
+    uint                 address,
+    vector<uint,4>       value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `address`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RWByteAddressBuffer.Store`
+
+## Signature 
+
+```
+/// See Target Availability 1
+void RWByteAddressBuffer.Store(
+    uint                 address,
+    uint                 value);
+/// See Target Availability 2
+void RWByteAddressBuffer.Store<T>(
+    int                  offset,
+    T                    value);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `address`
+* `value`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedByteAddressBuffer`
+
+## Methods
+
+* `GetDimensions`
+* `Load2`
+* `Load3`
+* `Load4`
+* `InterlockedAdd`
+* `InterlockedAnd`
+* `InterlockedCompareExchange`
+* `InterlockedCompareStore`
+* `InterlockedExchange`
+* `InterlockedMax`
+* `InterlockedMin`
+* `InterlockedOr`
+* `InterlockedXor`
+* `Store2`
+* `Store3`
+* `Store4`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.GetDimensions(out uint dim);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dim`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Load2`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,2> RasterizerOrderedByteAddressBuffer.Load2(int location);
+/// See Target Availability 2
+vector<uint,2> RasterizerOrderedByteAddressBuffer.Load2(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Load3`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,3> RasterizerOrderedByteAddressBuffer.Load3(int location);
+/// See Target Availability 2
+vector<uint,3> RasterizerOrderedByteAddressBuffer.Load3(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Load4`
+
+## Signature 
+
+```
+/// See Target Availability 1
+vector<uint,4> RasterizerOrderedByteAddressBuffer.Load4(int location);
+/// See Target Availability 2
+vector<uint,4> RasterizerOrderedByteAddressBuffer.Load4(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+uint RasterizerOrderedByteAddressBuffer.Load(int location);
+/// See Target Availability 2
+uint RasterizerOrderedByteAddressBuffer.Load(
+    int                  location,
+    out uint             status);
+T RasterizerOrderedByteAddressBuffer.Load<T>(int location);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedAdd`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedAdd(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RasterizerOrderedByteAddressBuffer.InterlockedAdd(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedAnd`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedAnd(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RasterizerOrderedByteAddressBuffer.InterlockedAnd(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedCompareExchange`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedCompareExchange(
+    uint                 dest,
+    uint                 compare_value,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `compare_value`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedCompareStore`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedCompareStore(
+    uint                 dest,
+    uint                 compare_value,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `compare_value`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedExchange`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedExchange(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedMax`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedMax(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RasterizerOrderedByteAddressBuffer.InterlockedMax(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedMin`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedMin(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RasterizerOrderedByteAddressBuffer.InterlockedMin(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedOr`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedOr(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RasterizerOrderedByteAddressBuffer.InterlockedOr(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.InterlockedXor`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.InterlockedXor(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+void RasterizerOrderedByteAddressBuffer.InterlockedXor(
+    uint                 dest,
+    uint                 value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Store2`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.Store2(
+    uint                 address,
+    vector<uint,2>       value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `address`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Store3`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.Store3(
+    uint                 address,
+    vector<uint,3>       value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `address`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Store4`
+
+## Signature 
+
+```
+void RasterizerOrderedByteAddressBuffer.Store4(
+    uint                 address,
+    vector<uint,4>       value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `address`
+* `value`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedByteAddressBuffer.Store`
+
+## Signature 
+
+```
+/// See Target Availability 1
+void RasterizerOrderedByteAddressBuffer.Store(
+    uint                 address,
+    uint                 value);
+/// See Target Availability 2
+void RasterizerOrderedByteAddressBuffer.Store<T>(
+    int                  offset,
+    T                    value);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `address`
+* `value`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `struct RWStructuredBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `DecrementCounter`
+* `GetDimensions`
+* `IncrementCounter`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RWStructuredBuffer<T>.DecrementCounter`
+
+## Signature 
+
+```
+uint RWStructuredBuffer<T>.DecrementCounter();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RWStructuredBuffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWStructuredBuffer<T>.GetDimensions(
+    out uint             numStructs,
+    out uint             stride);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `numStructs`
+* `stride`
+
+--------------------------------------------------------------------------------
+# `RWStructuredBuffer<T>.IncrementCounter`
+
+## Signature 
+
+```
+uint RWStructuredBuffer<T>.IncrementCounter();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RWStructuredBuffer<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWStructuredBuffer<T>.Load(int location);
+/// See Target Availability 2
+T RWStructuredBuffer<T>.Load(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWStructuredBuffer<T>.subscript`
+
+## Signature 
+
+```
+T RWStructuredBuffer<T>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedStructuredBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `DecrementCounter`
+* `GetDimensions`
+* `IncrementCounter`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedStructuredBuffer<T>.DecrementCounter`
+
+## Signature 
+
+```
+uint RasterizerOrderedStructuredBuffer<T>.DecrementCounter();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedStructuredBuffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedStructuredBuffer<T>.GetDimensions(
+    out uint             numStructs,
+    out uint             stride);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `numStructs`
+* `stride`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedStructuredBuffer<T>.IncrementCounter`
+
+## Signature 
+
+```
+uint RasterizerOrderedStructuredBuffer<T>.IncrementCounter();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedStructuredBuffer<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedStructuredBuffer<T>.Load(int location);
+/// See Target Availability 2
+T RasterizerOrderedStructuredBuffer<T>.Load(
+    int                  location,
+    out uint             status);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedStructuredBuffer<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedStructuredBuffer<T>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `struct PointStream<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `Append`
+* `RestartStrip`
+
+--------------------------------------------------------------------------------
+# `PointStream<T>.Append`
+
+## Signature 
+
+```
+void PointStream<T>.Append(T value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `PointStream<T>.RestartStrip`
+
+## Signature 
+
+```
+void PointStream<T>.RestartStrip();
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `struct LineStream<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `Append`
+* `RestartStrip`
+
+--------------------------------------------------------------------------------
+# `LineStream<T>.Append`
+
+## Signature 
+
+```
+void LineStream<T>.Append(T value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `LineStream<T>.RestartStrip`
+
+## Signature 
+
+```
+void LineStream<T>.RestartStrip();
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `struct TriangleStream<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `Append`
+* `RestartStrip`
+
+--------------------------------------------------------------------------------
+# `TriangleStream<T>.Append`
+
+## Signature 
+
+```
+void TriangleStream<T>.Append(T value);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `TriangleStream<T>.RestartStrip`
+
+## Signature 
+
+```
+void TriangleStream<T>.RestartStrip();
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `abort`
+
+## Signature 
+
+```
+void abort();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `abs`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T abs<T>(T x);
+/// See Target Availability 2
+vector<T,N> abs<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> abs<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `acos`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T acos<T>(T x);
+/// See Target Availability 2
+vector<T,N> acos<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> acos<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `all`
+
+## Signature 
+
+```
+/// See Target Availability 1
+bool all<T>(T x);
+bool all<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+bool all<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `AllMemoryBarrier`
+
+## Signature 
+
+```
+void AllMemoryBarrier();
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `AllMemoryBarrierWithGroupSync`
+
+## Signature 
+
+```
+void AllMemoryBarrierWithGroupSync();
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `any`
+
+## Signature 
+
+```
+/// See Target Availability 1
+bool any<T>(T x);
+bool any<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+bool any<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `asdouble`
+
+## Signature 
+
+```
+double asdouble(
+    uint                 lowbits,
+    uint                 highbits);
+```
+
+## Requirements
+
+`GLSL GL_ARB_gpu_shader5`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `lowbits`
+* `highbits`
+
+--------------------------------------------------------------------------------
+# `asfloat`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float asfloat(int x);
+float asfloat(uint x);
+vector<float,N> asfloat<N:int>(vector<int,N> x);
+vector<float,N> asfloat<N:int>(vector<uint,N> x);
+/// See Target Availability 2
+matrix<float,N,M> asfloat<N:int, M:int>(matrix<int,N,M> x);
+matrix<float,N,M> asfloat<N:int, M:int>(matrix<uint,N,M> x);
+float asfloat(float x);
+vector<float,N> asfloat<N:int>(vector<float,N> x);
+matrix<float,N,M> asfloat<N:int, M:int>(matrix<float,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `asin`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T asin<T>(T x);
+/// See Target Availability 2
+vector<T,N> asin<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> asin<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `asint`
+
+## Signature 
+
+```
+/// See Target Availability 1
+int asint(float x);
+int asint(uint x);
+vector<int,N> asint<N:int>(vector<float,N> x);
+vector<int,N> asint<N:int>(vector<uint,N> x);
+/// See Target Availability 2
+matrix<int,N,M> asint<N:int, M:int>(matrix<float,N,M> x);
+matrix<int,N,M> asint<N:int, M:int>(matrix<uint,N,M> x);
+int asint(int x);
+vector<int,N> asint<N:int>(vector<int,N> x);
+matrix<int,N,M> asint<N:int, M:int>(matrix<int,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `asuint`
+
+## Signature 
+
+```
+/// See Target Availability 1
+void asuint(
+    double               value,
+    out uint             lowbits,
+    out uint             highbits);
+uint asuint(float x);
+uint asuint(int x);
+vector<uint,N> asuint<N:int>(vector<float,N> x);
+vector<uint,N> asuint<N:int>(vector<int,N> x);
+/// See Target Availability 2
+matrix<uint,N,M> asuint<N:int, M:int>(matrix<float,N,M> x);
+matrix<uint,N,M> asuint<N:int, M:int>(matrix<int,N,M> x);
+uint asuint(uint x);
+vector<uint,N> asuint<N:int>(vector<uint,N> x);
+matrix<uint,N,M> asuint<N:int, M:int>(matrix<uint,N,M> x);
+```
+
+## Requirements
+
+`GLSL GL_ARB_gpu_shader5`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `N`
+* `M`
+* `value`
+* `lowbits`
+* `highbits`
+* `x`
+
+--------------------------------------------------------------------------------
+# `asuint16`
+
+## Signature 
+
+```
+/// See Target Availability 1
+uint16_t asuint16(uint16_t value);
+vector<uint16_t,N> asuint16<N:int>(vector<uint16_t,N> value);
+matrix<uint16_t,R,C> asuint16<R:int, C:int>(matrix<uint16_t,R,C> value);
+uint16_t asuint16(int16_t value);
+vector<uint16_t,N> asuint16<N:int>(vector<int16_t,N> value);
+matrix<uint16_t,R,C> asuint16<R:int, C:int>(matrix<int16_t,R,C> value);
+/// See Target Availability 2
+uint16_t asuint16(half value);
+/// See Target Availability 1
+vector<uint16_t,N> asuint16<N:int>(vector<half,N> value);
+matrix<uint16_t,R,C> asuint16<R:int, C:int>(matrix<half,R,C> value);
+```
+
+## Target Availability
+
+1. `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `N`
+* `R`
+* `C`
+* `value`
+
+--------------------------------------------------------------------------------
+# `asint16`
+
+## Signature 
+
+```
+int16_t asint16(int16_t value);
+vector<int16_t,N> asint16<N:int>(vector<int16_t,N> value);
+matrix<int16_t,R,C> asint16<R:int, C:int>(matrix<int16_t,R,C> value);
+int16_t asint16(uint16_t value);
+vector<int16_t,N> asint16<N:int>(vector<uint16_t,N> value);
+matrix<int16_t,R,C> asint16<R:int, C:int>(matrix<uint16_t,R,C> value);
+int16_t asint16(half value);
+vector<int16_t,N> asint16<N:int>(vector<half,N> value);
+matrix<int16_t,R,C> asint16<R:int, C:int>(matrix<half,R,C> value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `N`
+* `R`
+* `C`
+* `value`
+
+--------------------------------------------------------------------------------
+# `asfloat16`
+
+## Signature 
+
+```
+/// See Target Availability 1
+half asfloat16(half value);
+vector<half,N> asfloat16<N:int>(vector<half,N> value);
+matrix<half,R,C> asfloat16<R:int, C:int>(matrix<half,R,C> value);
+/// See Target Availability 2
+half asfloat16(uint16_t value);
+/// See Target Availability 1
+vector<half,N> asfloat16<N:int>(vector<uint16_t,N> value);
+matrix<half,R,C> asfloat16<R:int, C:int>(matrix<uint16_t,R,C> value);
+half asfloat16(int16_t value);
+vector<half,N> asfloat16<N:int>(vector<int16_t,N> value);
+matrix<half,R,C> asfloat16<R:int, C:int>(matrix<int16_t,R,C> value);
+```
+
+## Target Availability
+
+1. `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `N`
+* `R`
+* `C`
+* `value`
+
+--------------------------------------------------------------------------------
+# `atan`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T atan<T>(T x);
+/// See Target Availability 2
+vector<T,N> atan<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> atan<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `atan2`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T atan2<T>(
+    T                    y,
+    T                    x);
+/// See Target Availability 2
+vector<T,N> atan2<T, N:int>(
+    vector<T,N>          y,
+    vector<T,N>          x);
+/// See Target Availability 3
+matrix<T,N,M> atan2<T, N:int, M:int>(
+    matrix<T,N,M>        y,
+    matrix<T,N,M>        x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `y`
+* `x`
+
+--------------------------------------------------------------------------------
+# `ceil`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T ceil<T>(T x);
+/// See Target Availability 2
+vector<T,N> ceil<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> ceil<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `CheckAccessFullyMapped`
+
+## Signature 
+
+```
+bool CheckAccessFullyMapped(uint status);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `status`
+
+--------------------------------------------------------------------------------
+# `clamp`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T clamp<T>(
+    T                    x,
+    T                    minBound,
+    T                    maxBound);
+vector<T,N> clamp<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          minBound,
+    vector<T,N>          maxBound);
+/// See Target Availability 2
+matrix<T,N,M> clamp<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    matrix<T,N,M>        minBound,
+    matrix<T,N,M>        maxBound);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `minBound`
+* `maxBound`
+
+--------------------------------------------------------------------------------
+# `clip`
+
+## Signature 
+
+```
+void clip<T>(T x);
+void clip<T, N:int>(vector<T,N> x);
+void clip<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `cos`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T cos<T>(T x);
+/// See Target Availability 2
+vector<T,N> cos<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> cos<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `cosh`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T cosh<T>(T x);
+/// See Target Availability 2
+vector<T,N> cosh<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> cosh<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `countbits`
+
+## Signature 
+
+```
+uint countbits(uint value);
+```
+
+## Target Availability
+
+`CPP`, `CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `cross`
+
+## Signature 
+
+```
+vector<T,3> cross<T>(
+    vector<T,3>          left,
+    vector<T,3>          right);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `left`
+* `right`
+
+--------------------------------------------------------------------------------
+# `D3DCOLORtoUBYTE4`
+
+## Signature 
+
+```
+vector<int,4> D3DCOLORtoUBYTE4(vector<float,4> color);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `color`
+
+--------------------------------------------------------------------------------
+# `ddx`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T ddx<T>(T x);
+vector<T,N> ddx<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> ddx<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `ddx_coarse`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T ddx_coarse<T>(T x);
+vector<T,N> ddx_coarse<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> ddx_coarse<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Requirements
+
+`GLSL GL_ARB_derivative_control`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `ddx_fine`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T ddx_fine<T>(T x);
+vector<T,N> ddx_fine<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> ddx_fine<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Requirements
+
+`GLSL GL_ARB_derivative_control`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `ddy`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T ddy<T>(T x);
+vector<T,N> ddy<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> ddy<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `ddy_coarse`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T ddy_coarse<T>(T x);
+vector<T,N> ddy_coarse<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> ddy_coarse<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Requirements
+
+`GLSL GL_ARB_derivative_control`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `ddy_fine`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T ddy_fine<T>(T x);
+vector<T,N> ddy_fine<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> ddy_fine<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Requirements
+
+`GLSL GL_ARB_derivative_control`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `degrees`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T degrees<T>(T x);
+vector<T,N> degrees<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> degrees<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `determinant`
+
+## Signature 
+
+```
+T determinant<T, N:int>(matrix<T,N,N> m);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `m`
+
+--------------------------------------------------------------------------------
+# `DeviceMemoryBarrier`
+
+## Signature 
+
+```
+void DeviceMemoryBarrier();
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `DeviceMemoryBarrierWithGroupSync`
+
+## Signature 
+
+```
+void DeviceMemoryBarrierWithGroupSync();
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `distance`
+
+## Signature 
+
+```
+T distance<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `x`
+* `y`
+
+--------------------------------------------------------------------------------
+# `dot`
+
+## Signature 
+
+```
+T dot<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `x`
+* `y`
+
+--------------------------------------------------------------------------------
+# `dst`
+
+## Signature 
+
+```
+vector<T,4> dst<T>(
+    vector<T,4>          x,
+    vector<T,4>          y);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `x`
+* `y`
+
+--------------------------------------------------------------------------------
+# `EvaluateAttributeAtCentroid`
+
+## Signature 
+
+```
+T EvaluateAttributeAtCentroid<T>(T x);
+vector<T,N> EvaluateAttributeAtCentroid<T, N:int>(vector<T,N> x);
+matrix<T,N,M> EvaluateAttributeAtCentroid<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `EvaluateAttributeAtSample`
+
+## Signature 
+
+```
+T EvaluateAttributeAtSample<T>(
+    T                    x,
+    uint                 sampleindex);
+vector<T,N> EvaluateAttributeAtSample<T, N:int>(
+    vector<T,N>          x,
+    uint                 sampleindex);
+matrix<T,N,M> EvaluateAttributeAtSample<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    uint                 sampleindex);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `sampleindex`
+
+--------------------------------------------------------------------------------
+# `EvaluateAttributeSnapped`
+
+## Signature 
+
+```
+T EvaluateAttributeSnapped<T>(
+    T                    x,
+    vector<int,2>        offset);
+vector<T,N> EvaluateAttributeSnapped<T, N:int>(
+    vector<T,N>          x,
+    vector<int,2>        offset);
+matrix<T,N,M> EvaluateAttributeSnapped<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    vector<int,2>        offset);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `offset`
+
+--------------------------------------------------------------------------------
+# `exp`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T exp<T>(T x);
+/// See Target Availability 2
+vector<T,N> exp<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> exp<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `exp2`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T exp2<T>(T x);
+/// See Target Availability 2
+vector<T,N> exp2<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> exp2<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `f16tof32`
+
+## Signature 
+
+```
+/// See Target Availability 1
+float f16tof32(uint value);
+/// See Target Availability 2
+vector<float,N> f16tof32<N:int>(vector<uint,N> value);
+```
+
+## Requirements
+
+`GLSL420`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `N`
+* `value`
+
+--------------------------------------------------------------------------------
+# `f32tof16`
+
+## Signature 
+
+```
+/// See Target Availability 1
+uint f32tof16(float value);
+/// See Target Availability 2
+vector<uint,N> f32tof16<N:int>(vector<float,N> value);
+```
+
+## Requirements
+
+`GLSL420`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `N`
+* `value`
+
+--------------------------------------------------------------------------------
+# `faceforward`
+
+## Signature 
+
+```
+vector<T,N> faceforward<T, N:int>(
+    vector<T,N>          n,
+    vector<T,N>          i,
+    vector<T,N>          ng);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `n`
+* `i`
+* `ng`
+
+--------------------------------------------------------------------------------
+# `firstbithigh`
+
+## Signature 
+
+```
+/// See Target Availability 1
+int firstbithigh(int value);
+/// See Target Availability 2
+vector<int,N> firstbithigh<N:int>(vector<int,N> value);
+/// See Target Availability 1
+uint firstbithigh(uint value);
+/// See Target Availability 2
+vector<uint,N> firstbithigh<N:int>(vector<uint,N> value);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `N`
+* `value`
+
+--------------------------------------------------------------------------------
+# `firstbitlow`
+
+## Signature 
+
+```
+/// See Target Availability 1
+int firstbitlow(int value);
+/// See Target Availability 2
+vector<int,N> firstbitlow<N:int>(vector<int,N> value);
+/// See Target Availability 1
+uint firstbitlow(uint value);
+/// See Target Availability 2
+vector<uint,N> firstbitlow<N:int>(vector<uint,N> value);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `N`
+* `value`
+
+--------------------------------------------------------------------------------
+# `floor`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T floor<T>(T x);
+/// See Target Availability 2
+vector<T,N> floor<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> floor<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `fma`
+
+## Signature 
+
+```
+/// See Target Availability 1
+double fma(
+    double               a,
+    double               b,
+    double               c);
+/// See Target Availability 2
+vector<double,N> fma<N:int>(
+    vector<double,N>     a,
+    vector<double,N>     b,
+    vector<double,N>     c);
+/// See Target Availability 3
+matrix<double,N,M> fma<N:int, M:int>(
+    matrix<double,N,M>   a,
+    matrix<double,N,M>   b,
+    matrix<double,N,M>   c);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `N`
+* `M`
+* `a`
+* `b`
+* `c`
+
+--------------------------------------------------------------------------------
+# `fmod`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T fmod<T>(
+    T                    x,
+    T                    y);
+/// See Target Availability 2
+vector<T,N> fmod<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y);
+matrix<T,N,M> fmod<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    matrix<T,N,M>        y);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `y`
+
+--------------------------------------------------------------------------------
+# `frac`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T frac<T>(T x);
+/// See Target Availability 2
+vector<T,N> frac<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> frac<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `frexp`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T frexp<T>(
+    T                    x,
+    out T                exp);
+vector<T,N> frexp<T, N:int>(
+    vector<T,N>          x,
+    out vector<T,N>      exp);
+/// See Target Availability 2
+matrix<T,N,M> frexp<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    out matrix<T,N,M>    exp);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `exp`
+
+--------------------------------------------------------------------------------
+# `fwidth`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T fwidth<T>(T x);
+/// See Target Availability 2
+vector<T,N> fwidth<T, N:int>(vector<T,N> x);
+/// See Target Availability 1
+matrix<T,N,M> fwidth<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `GetAttributeAtVertex`
+
+## Description
+
+ Get the value of a vertex attribute at a specific vertex.
+
+ The `GetAttributeAtVertex()` function can be used in a fragment shader
+ to get the value of the given `attribute` at the vertex of the primitive
+ that corresponds to the given `vertexIndex`.
+
+ Note that the `attribute` must have been a declared varying input to
+ the fragment shader with the `nointerpolation` modifier.
+
+ This function can be applied to scalars, vectors, and matrices of
+ built-in scalar types.
+
+ Note: these functions are not curently implemented for Vulkan/SPIR-V output.
+
+## Signature 
+
+```
+T GetAttributeAtVertex<T>(
+    T                    attribute,
+    uint                 vertexIndex);
+vector<T,N> GetAttributeAtVertex<T, N:int>(
+    vector<T,N>          attribute,
+    uint                 vertexIndex);
+matrix<T,N,M> GetAttributeAtVertex<T, N:int, M:int>(
+    matrix<T,N,M>        attribute,
+    uint                 vertexIndex);
+```
+
+## Requirements
+
+`GLSL GL_NV_fragment_shader_barycentric`, `GLSL450`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `attribute`
+* `vertexIndex`
+
+--------------------------------------------------------------------------------
+# `GetRenderTargetSampleCount`
+
+## Signature 
+
+```
+uint GetRenderTargetSampleCount();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `GetRenderTargetSamplePosition`
+
+## Signature 
+
+```
+vector<float,2> GetRenderTargetSamplePosition(int Index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `Index`
+
+--------------------------------------------------------------------------------
+# `GroupMemoryBarrier`
+
+## Signature 
+
+```
+void GroupMemoryBarrier();
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `GroupMemoryBarrierWithGroupSync`
+
+## Signature 
+
+```
+void GroupMemoryBarrierWithGroupSync();
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `InterlockedAdd`
+
+## Signature 
+
+```
+void InterlockedAdd(
+    int                  dest,
+    int                  value);
+void InterlockedAdd(
+    uint                 dest,
+    uint                 value);
+void InterlockedAdd(
+    int                  dest,
+    int                  value,
+    out int              original_value);
+void InterlockedAdd(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `InterlockedAnd`
+
+## Signature 
+
+```
+void InterlockedAnd(
+    int                  dest,
+    int                  value);
+void InterlockedAnd(
+    uint                 dest,
+    uint                 value);
+void InterlockedAnd(
+    int                  dest,
+    int                  value,
+    out int              original_value);
+void InterlockedAnd(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `InterlockedCompareExchange`
+
+## Signature 
+
+```
+void InterlockedCompareExchange(
+    int                  dest,
+    int                  compare_value,
+    int                  value,
+    out int              original_value);
+void InterlockedCompareExchange(
+    uint                 dest,
+    uint                 compare_value,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `compare_value`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `InterlockedCompareStore`
+
+## Signature 
+
+```
+void InterlockedCompareStore(
+    int                  dest,
+    int                  compare_value,
+    int                  value);
+void InterlockedCompareStore(
+    uint                 dest,
+    uint                 compare_value,
+    uint                 value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `compare_value`
+* `value`
+
+--------------------------------------------------------------------------------
+# `InterlockedExchange`
+
+## Signature 
+
+```
+void InterlockedExchange(
+    int                  dest,
+    int                  value,
+    out int              original_value);
+void InterlockedExchange(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `InterlockedMax`
+
+## Signature 
+
+```
+void InterlockedMax(
+    int                  dest,
+    int                  value);
+void InterlockedMax(
+    uint                 dest,
+    uint                 value);
+void InterlockedMax(
+    int                  dest,
+    int                  value,
+    out int              original_value);
+void InterlockedMax(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `InterlockedMin`
+
+## Signature 
+
+```
+void InterlockedMin(
+    int                  dest,
+    int                  value);
+void InterlockedMin(
+    uint                 dest,
+    uint                 value);
+void InterlockedMin(
+    int                  dest,
+    int                  value,
+    out int              original_value);
+void InterlockedMin(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `InterlockedOr`
+
+## Signature 
+
+```
+void InterlockedOr(
+    int                  dest,
+    int                  value);
+void InterlockedOr(
+    uint                 dest,
+    uint                 value);
+void InterlockedOr(
+    int                  dest,
+    int                  value,
+    out int              original_value);
+void InterlockedOr(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `InterlockedXor`
+
+## Signature 
+
+```
+void InterlockedXor(
+    int                  dest,
+    int                  value);
+void InterlockedXor(
+    uint                 dest,
+    uint                 value);
+void InterlockedXor(
+    int                  dest,
+    int                  value,
+    out int              original_value);
+void InterlockedXor(
+    uint                 dest,
+    uint                 value,
+    out uint             original_value);
+```
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `dest`
+* `value`
+* `original_value`
+
+--------------------------------------------------------------------------------
+# `isfinite`
+
+## Signature 
+
+```
+/// See Target Availability 1
+bool isfinite<T>(T x);
+/// See Target Availability 2
+vector<bool,N> isfinite<T, N:int>(vector<T,N> x);
+matrix<bool,N,M> isfinite<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `isinf`
+
+## Signature 
+
+```
+/// See Target Availability 1
+bool isinf<T>(T x);
+/// See Target Availability 2
+vector<bool,N> isinf<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<bool,N,M> isinf<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `isnan`
+
+## Signature 
+
+```
+/// See Target Availability 1
+bool isnan<T>(T x);
+/// See Target Availability 2
+vector<bool,N> isnan<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<bool,N,M> isnan<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `ldexp`
+
+## Signature 
+
+```
+T ldexp<T>(
+    T                    x,
+    T                    exp);
+vector<T,N> ldexp<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          exp);
+matrix<T,N,M> ldexp<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    matrix<T,N,M>        exp);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `exp`
+
+--------------------------------------------------------------------------------
+# `length`
+
+## Signature 
+
+```
+T length<T, N:int>(vector<T,N> x);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `x`
+
+--------------------------------------------------------------------------------
+# `lerp`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T lerp<T>(
+    T                    x,
+    T                    y,
+    T                    s);
+vector<T,N> lerp<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y,
+    vector<T,N>          s);
+/// See Target Availability 2
+matrix<T,N,M> lerp<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    matrix<T,N,M>        y,
+    matrix<T,N,M>        s);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `y`
+* `s`
+
+--------------------------------------------------------------------------------
+# `lit`
+
+## Signature 
+
+```
+vector<float,4> lit(
+    float                n_dot_l,
+    float                n_dot_h,
+    float                m);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `n_dot_l`
+* `n_dot_h`
+* `m`
+
+--------------------------------------------------------------------------------
+# `log`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T log<T>(T x);
+/// See Target Availability 2
+vector<T,N> log<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> log<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `log10`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T log10<T>(T x);
+/// See Target Availability 2
+vector<T,N> log10<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> log10<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `log2`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T log2<T>(T x);
+/// See Target Availability 2
+vector<T,N> log2<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> log2<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `mad`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T mad<T>(
+    T                    mvalue,
+    T                    avalue,
+    T                    bvalue);
+/// See Target Availability 2
+vector<T,N> mad<T, N:int>(
+    vector<T,N>          mvalue,
+    vector<T,N>          avalue,
+    vector<T,N>          bvalue);
+/// See Target Availability 3
+matrix<T,N,M> mad<T, N:int, M:int>(
+    matrix<T,N,M>        mvalue,
+    matrix<T,N,M>        avalue,
+    matrix<T,N,M>        bvalue);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mvalue`
+* `avalue`
+* `bvalue`
+
+--------------------------------------------------------------------------------
+# `max`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T max<T>(
+    T                    x,
+    T                    y);
+/// See Target Availability 2
+vector<T,N> max<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y);
+/// See Target Availability 3
+matrix<T,N,M> max<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    matrix<T,N,M>        y);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `y`
+
+--------------------------------------------------------------------------------
+# `min`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T min<T>(
+    T                    x,
+    T                    y);
+/// See Target Availability 2
+vector<T,N> min<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y);
+/// See Target Availability 3
+matrix<T,N,M> min<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    matrix<T,N,M>        y);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `y`
+
+--------------------------------------------------------------------------------
+# `modf`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T modf<T>(
+    T                    x,
+    out T                ip);
+/// See Target Availability 2
+vector<T,N> modf<T, N:int>(
+    vector<T,N>          x,
+    out vector<T,N>      ip);
+/// See Target Availability 1
+matrix<T,N,M> modf<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    out matrix<T,N,M>    ip);
+```
+
+## Target Availability
+
+1. `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `ip`
+
+--------------------------------------------------------------------------------
+# `msad4`
+
+## Signature 
+
+```
+vector<uint,4> msad4(
+    uint                 reference,
+    vector<uint,2>       source,
+    vector<uint,4>       accum);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `reference`
+* `source`
+* `accum`
+
+--------------------------------------------------------------------------------
+# `mul`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T mul<T>(
+    T                    x,
+    T                    y);
+vector<T,N> mul<T, N:int>(
+    vector<T,N>          x,
+    T                    y);
+vector<T,N> mul<T, N:int>(
+    T                    x,
+    vector<T,N>          y);
+matrix<T,N,M> mul<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    T                    y);
+matrix<T,N,M> mul<T, N:int, M:int>(
+    T                    x,
+    matrix<T,N,M>        y);
+/// See Target Availability 2
+T mul<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y);
+vector<T,M> mul<T, N:int, M:int>(
+    vector<T,N>          left,
+    matrix<T,N,M>        right);
+vector<T,N> mul<T, N:int, M:int>(
+    matrix<T,N,M>        left,
+    vector<T,M>          right);
+matrix<T,R,C> mul<T, R:int, N:int, C:int>(
+    matrix<T,R,N>        right,
+    matrix<T,N,C>        left);
+```
+
+## Target Availability
+
+1. `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `R`
+* `C`
+* `x`
+* `y`
+* `left`
+* `right`
+
+--------------------------------------------------------------------------------
+# `noise`
+
+## Signature 
+
+```
+float noise(float x);
+float noise<N:int>(vector<float,N> x);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `N`
+* `x`
+
+--------------------------------------------------------------------------------
+# `NonUniformResourceIndex`
+
+## Signature 
+
+```
+uint NonUniformResourceIndex(uint index);
+int NonUniformResourceIndex(int index);
+```
+
+## Requirements
+
+`GLSL GL_EXT_nonuniform_qualifier`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `normalize`
+
+## Signature 
+
+```
+vector<T,N> normalize<T, N:int>(vector<T,N> x);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `x`
+
+--------------------------------------------------------------------------------
+# `pow`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T pow<T>(
+    T                    x,
+    T                    y);
+/// See Target Availability 2
+vector<T,N> pow<T, N:int>(
+    vector<T,N>          x,
+    vector<T,N>          y);
+/// See Target Availability 3
+matrix<T,N,M> pow<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    matrix<T,N,M>        y);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `y`
+
+--------------------------------------------------------------------------------
+# `Process2DQuadTessFactorsAvg`
+
+## Signature 
+
+```
+void Process2DQuadTessFactorsAvg(
+    in vector<float,4>   RawEdgeFactors,
+    in vector<float,2>   InsideScale,
+    out vector<float,4>  RoundedEdgeTessFactors,
+    out vector<float,2>  RoundedInsideTessFactors,
+    out vector<float,2>  UnroundedInsideTessFactors);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactors`
+* `UnroundedInsideTessFactors`
+
+--------------------------------------------------------------------------------
+# `Process2DQuadTessFactorsMax`
+
+## Signature 
+
+```
+void Process2DQuadTessFactorsMax(
+    in vector<float,4>   RawEdgeFactors,
+    in vector<float,2>   InsideScale,
+    out vector<float,4>  RoundedEdgeTessFactors,
+    out vector<float,2>  RoundedInsideTessFactors,
+    out vector<float,2>  UnroundedInsideTessFactors);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactors`
+* `UnroundedInsideTessFactors`
+
+--------------------------------------------------------------------------------
+# `Process2DQuadTessFactorsMin`
+
+## Signature 
+
+```
+void Process2DQuadTessFactorsMin(
+    in vector<float,4>   RawEdgeFactors,
+    in vector<float,2>   InsideScale,
+    out vector<float,4>  RoundedEdgeTessFactors,
+    out vector<float,2>  RoundedInsideTessFactors,
+    out vector<float,2>  UnroundedInsideTessFactors);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactors`
+* `UnroundedInsideTessFactors`
+
+--------------------------------------------------------------------------------
+# `ProcessIsolineTessFactors`
+
+## Signature 
+
+```
+void ProcessIsolineTessFactors(
+    in float             RawDetailFactor,
+    in float             RawDensityFactor,
+    out float            RoundedDetailFactor,
+    out float            RoundedDensityFactor);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawDetailFactor`
+* `RawDensityFactor`
+* `RoundedDetailFactor`
+* `RoundedDensityFactor`
+
+--------------------------------------------------------------------------------
+# `ProcessQuadTessFactorsAvg`
+
+## Signature 
+
+```
+void ProcessQuadTessFactorsAvg(
+    in vector<float,4>   RawEdgeFactors,
+    in float             InsideScale,
+    out vector<float,4>  RoundedEdgeTessFactors,
+    out vector<float,2>  RoundedInsideTessFactors,
+    out vector<float,2>  UnroundedInsideTessFactors);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactors`
+* `UnroundedInsideTessFactors`
+
+--------------------------------------------------------------------------------
+# `ProcessQuadTessFactorsMax`
+
+## Signature 
+
+```
+void ProcessQuadTessFactorsMax(
+    in vector<float,4>   RawEdgeFactors,
+    in float             InsideScale,
+    out vector<float,4>  RoundedEdgeTessFactors,
+    out vector<float,2>  RoundedInsideTessFactors,
+    out vector<float,2>  UnroundedInsideTessFactors);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactors`
+* `UnroundedInsideTessFactors`
+
+--------------------------------------------------------------------------------
+# `ProcessQuadTessFactorsMin`
+
+## Signature 
+
+```
+void ProcessQuadTessFactorsMin(
+    in vector<float,4>   RawEdgeFactors,
+    in float             InsideScale,
+    out vector<float,4>  RoundedEdgeTessFactors,
+    out vector<float,2>  RoundedInsideTessFactors,
+    out vector<float,2>  UnroundedInsideTessFactors);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactors`
+* `UnroundedInsideTessFactors`
+
+--------------------------------------------------------------------------------
+# `ProcessTriTessFactorsAvg`
+
+## Signature 
+
+```
+void ProcessTriTessFactorsAvg(
+    in vector<float,3>   RawEdgeFactors,
+    in float             InsideScale,
+    out vector<float,3>  RoundedEdgeTessFactors,
+    out float            RoundedInsideTessFactor,
+    out float            UnroundedInsideTessFactor);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactor`
+* `UnroundedInsideTessFactor`
+
+--------------------------------------------------------------------------------
+# `ProcessTriTessFactorsMax`
+
+## Signature 
+
+```
+void ProcessTriTessFactorsMax(
+    in vector<float,3>   RawEdgeFactors,
+    in float             InsideScale,
+    out vector<float,3>  RoundedEdgeTessFactors,
+    out float            RoundedInsideTessFactor,
+    out float            UnroundedInsideTessFactor);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactor`
+* `UnroundedInsideTessFactor`
+
+--------------------------------------------------------------------------------
+# `ProcessTriTessFactorsMin`
+
+## Signature 
+
+```
+void ProcessTriTessFactorsMin(
+    in vector<float,3>   RawEdgeFactors,
+    in float             InsideScale,
+    out vector<float,3>  RoundedEdgeTessFactors,
+    out float            RoundedInsideTessFactors,
+    out float            UnroundedInsideTessFactors);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `RawEdgeFactors`
+* `InsideScale`
+* `RoundedEdgeTessFactors`
+* `RoundedInsideTessFactors`
+* `UnroundedInsideTessFactors`
+
+--------------------------------------------------------------------------------
+# `radians`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T radians<T>(T x);
+vector<T,N> radians<T, N:int>(vector<T,N> x);
+/// See Target Availability 2
+matrix<T,N,M> radians<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `rcp`
+
+## Signature 
+
+```
+T rcp<T>(T x);
+vector<T,N> rcp<T, N:int>(vector<T,N> x);
+matrix<T,N,M> rcp<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `reflect`
+
+## Signature 
+
+```
+vector<T,N> reflect<T, N:int>(
+    vector<T,N>          i,
+    vector<T,N>          n);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `i`
+* `n`
+
+--------------------------------------------------------------------------------
+# `refract`
+
+## Signature 
+
+```
+vector<T,N> refract<T, N:int>(
+    vector<T,N>          i,
+    vector<T,N>          n,
+    T                    eta);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `i`
+* `n`
+* `eta`
+
+--------------------------------------------------------------------------------
+# `reversebits`
+
+## Signature 
+
+```
+/// See Target Availability 1
+uint reversebits(uint value);
+/// See Target Availability 2
+vector<uint,N> reversebits<N:int>(vector<uint,N> value);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+
+## Parameters
+
+* `N`
+* `value`
+
+--------------------------------------------------------------------------------
+# `round`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T round<T>(T x);
+/// See Target Availability 2
+vector<T,N> round<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> round<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `rsqrt`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T rsqrt<T>(T x);
+/// See Target Availability 2
+vector<T,N> rsqrt<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> rsqrt<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `saturate`
+
+## Signature 
+
+```
+T saturate<T>(T x);
+vector<T,N> saturate<T, N:int>(vector<T,N> x);
+matrix<T,N,M> saturate<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `sign`
+
+## Signature 
+
+```
+/// See Target Availability 1
+int sign<T>(T x);
+/// See Target Availability 2
+vector<int,N> sign<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<int,N,M> sign<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `sin`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T sin<T>(T x);
+/// See Target Availability 2
+vector<T,N> sin<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> sin<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `sincos`
+
+## Signature 
+
+```
+/// See Target Availability 1
+void sincos<T>(
+    T                    x,
+    out T                s,
+    out T                c);
+/// See Target Availability 2
+void sincos<T, N:int>(
+    vector<T,N>          x,
+    out vector<T,N>      s,
+    out vector<T,N>      c);
+void sincos<T, N:int, M:int>(
+    matrix<T,N,M>        x,
+    out matrix<T,N,M>    s,
+    out matrix<T,N,M>    c);
+```
+
+## Target Availability
+
+1. `CUDA`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+* `s`
+* `c`
+
+--------------------------------------------------------------------------------
+# `sinh`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T sinh<T>(T x);
+/// See Target Availability 2
+vector<T,N> sinh<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> sinh<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `smoothstep`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T smoothstep<T>(
+    T                    min,
+    T                    max,
+    T                    x);
+vector<T,N> smoothstep<T, N:int>(
+    vector<T,N>          min,
+    vector<T,N>          max,
+    vector<T,N>          x);
+/// See Target Availability 2
+matrix<T,N,M> smoothstep<T, N:int, M:int>(
+    matrix<T,N,M>        min,
+    matrix<T,N,M>        max,
+    matrix<T,N,M>        x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `min`
+* `max`
+* `x`
+
+--------------------------------------------------------------------------------
+# `sqrt`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T sqrt<T>(T x);
+/// See Target Availability 2
+vector<T,N> sqrt<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> sqrt<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `step`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T step<T>(
+    T                    y,
+    T                    x);
+vector<T,N> step<T, N:int>(
+    vector<T,N>          y,
+    vector<T,N>          x);
+/// See Target Availability 2
+matrix<T,N,M> step<T, N:int, M:int>(
+    matrix<T,N,M>        y,
+    matrix<T,N,M>        x);
+```
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `y`
+* `x`
+
+--------------------------------------------------------------------------------
+# `tan`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T tan<T>(T x);
+/// See Target Availability 2
+vector<T,N> tan<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> tan<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `tanh`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T tanh<T>(T x);
+/// See Target Availability 2
+vector<T,N> tanh<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> tanh<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `transpose`
+
+## Signature 
+
+```
+matrix<T,M,N> transpose<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `trunc`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T trunc<T>(T x);
+/// See Target Availability 2
+vector<T,N> trunc<T, N:int>(vector<T,N> x);
+/// See Target Availability 3
+matrix<T,N,M> trunc<T, N:int, M:int>(matrix<T,N,M> x);
+```
+
+## Target Availability
+
+1. `CPP`, `CUDA`, `GLSL`, `HLSL`
+2. `GLSL`, `HLSL`
+3. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `x`
+
+--------------------------------------------------------------------------------
+# `WaveGetConvergedMask`
+
+## Signature 
+
+```
+uint WaveGetConvergedMask();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WaveGetActiveMask`
+
+## Signature 
+
+```
+uint WaveGetActiveMask();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WaveMaskIsFirstLane`
+
+## Signature 
+
+```
+bool WaveMaskIsFirstLane(uint mask);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `mask`
+
+--------------------------------------------------------------------------------
+# `WaveMaskAllTrue`
+
+## Signature 
+
+```
+bool WaveMaskAllTrue(
+    uint                 mask,
+    bool                 condition);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `mask`
+* `condition`
+
+--------------------------------------------------------------------------------
+# `WaveMaskAnyTrue`
+
+## Signature 
+
+```
+bool WaveMaskAnyTrue(
+    uint                 mask,
+    bool                 condition);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `mask`
+* `condition`
+
+--------------------------------------------------------------------------------
+# `WaveMaskBallot`
+
+## Signature 
+
+```
+uint WaveMaskBallot(
+    uint                 mask,
+    bool                 condition);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `mask`
+* `condition`
+
+--------------------------------------------------------------------------------
+# `WaveMaskCountBits`
+
+## Signature 
+
+```
+uint WaveMaskCountBits(
+    uint                 mask,
+    bool                 value);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `mask`
+* `value`
+
+--------------------------------------------------------------------------------
+# `AllMemoryBarrierWithWaveMaskSync`
+
+## Signature 
+
+```
+void AllMemoryBarrierWithWaveMaskSync(uint mask);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `mask`
+
+--------------------------------------------------------------------------------
+# `GroupMemoryBarrierWithWaveMaskSync`
+
+## Signature 
+
+```
+void GroupMemoryBarrierWithWaveMaskSync(uint mask);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `mask`
+
+--------------------------------------------------------------------------------
+# `AllMemoryBarrierWithWaveSync`
+
+## Signature 
+
+```
+void AllMemoryBarrierWithWaveSync();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `GroupMemoryBarrierWithWaveSync`
+
+## Signature 
+
+```
+void GroupMemoryBarrierWithWaveSync();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WaveMaskBroadcastLaneAt`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskBroadcastLaneAt<T>(
+    uint                 mask,
+    T                    value,
+    int                  lane);
+vector<T,N> WaveMaskBroadcastLaneAt<T, N:int>(
+    uint                 mask,
+    vector<T,N>          value,
+    int                  lane);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskBroadcastLaneAt<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        value,
+    int                  lane);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `value`
+* `lane`
+
+--------------------------------------------------------------------------------
+# `WaveMaskReadLaneAt`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskReadLaneAt<T>(
+    uint                 mask,
+    T                    value,
+    int                  lane);
+vector<T,N> WaveMaskReadLaneAt<T, N:int>(
+    uint                 mask,
+    vector<T,N>          value,
+    int                  lane);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskReadLaneAt<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        value,
+    int                  lane);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `value`
+* `lane`
+
+--------------------------------------------------------------------------------
+# `WaveMaskShuffle`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskShuffle<T>(
+    uint                 mask,
+    T                    value,
+    int                  lane);
+vector<T,N> WaveMaskShuffle<T, N:int>(
+    uint                 mask,
+    vector<T,N>          value,
+    int                  lane);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskShuffle<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        value,
+    int                  lane);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `value`
+* `lane`
+
+--------------------------------------------------------------------------------
+# `WaveMaskPrefixCountBits`
+
+## Signature 
+
+```
+uint WaveMaskPrefixCountBits(
+    uint                 mask,
+    bool                 value);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `mask`
+* `value`
+
+--------------------------------------------------------------------------------
+# `WaveMaskBitAnd`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskBitAnd<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskBitAnd<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskBitAnd<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskBitOr`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskBitOr<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskBitOr<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskBitOr<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskBitXor`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskBitXor<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskBitXor<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskBitXor<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskMax`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskMax<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskMax<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskMax<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskMin`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskMin<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskMin<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskMin<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskProduct`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskProduct<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskProduct<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskProduct<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskSum`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskSum<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskSum<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskSum<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskAllEqual`
+
+## Signature 
+
+```
+/// See Requirement 1
+/// See Target Availability 1
+bool WaveMaskAllEqual<T>(
+    uint                 mask,
+    T                    value);
+bool WaveMaskAllEqual<T, N:int>(
+    uint                 mask,
+    vector<T,N>          value);
+/// See Requirement 2
+/// See Target Availability 2
+bool WaveMaskAllEqual<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        value);
+```
+
+## Requirements
+
+1. `CUDA SM 7.0`, `GLSL GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3`
+2. `CUDA SM 7.0`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `value`
+
+--------------------------------------------------------------------------------
+# `WaveMaskPrefixProduct`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskPrefixProduct<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskPrefixProduct<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskPrefixProduct<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskPrefixSum`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskPrefixSum<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskPrefixSum<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskPrefixSum<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskReadLaneFirst`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskReadLaneFirst<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskReadLaneFirst<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskReadLaneFirst<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskMatch`
+
+## Signature 
+
+```
+uint WaveMaskMatch<T>(
+    uint                 mask,
+    T                    value);
+uint WaveMaskMatch<T, N:int>(
+    uint                 mask,
+    vector<T,N>          value);
+uint WaveMaskMatch<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        value);
+```
+
+## Requirements
+
+`CUDA SM 7.0`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `value`
+
+--------------------------------------------------------------------------------
+# `WaveMaskPrefixBitAnd`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskPrefixBitAnd<T>(
+    uint                 mask,
+    T                    expr);
+/// See Target Availability 2
+vector<T,N> WaveMaskPrefixBitAnd<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 1
+matrix<T,N,M> WaveMaskPrefixBitAnd<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `HLSL`
+2. `CUDA`, `GLSL`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskPrefixBitOr`
+
+## Signature 
+
+```
+T WaveMaskPrefixBitOr<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskPrefixBitOr<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+matrix<T,N,M> WaveMaskPrefixBitOr<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveMaskPrefixBitXor`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMaskPrefixBitXor<T>(
+    uint                 mask,
+    T                    expr);
+vector<T,N> WaveMaskPrefixBitXor<T, N:int>(
+    uint                 mask,
+    vector<T,N>          expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveMaskPrefixBitXor<T, N:int, M:int>(
+    uint                 mask,
+    matrix<T,N,M>        expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `mask`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `QuadReadLaneAt`
+
+## Signature 
+
+```
+T QuadReadLaneAt<T>(
+    T                    sourceValue,
+    uint                 quadLaneID);
+vector<T,N> QuadReadLaneAt<T, N:int>(
+    vector<T,N>          sourceValue,
+    uint                 quadLaneID);
+matrix<T,N,M> QuadReadLaneAt<T, N:int, M:int>(
+    matrix<T,N,M>        sourceValue,
+    uint                 quadLaneID);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `sourceValue`
+* `quadLaneID`
+
+--------------------------------------------------------------------------------
+# `QuadReadAcrossX`
+
+## Signature 
+
+```
+T QuadReadAcrossX<T>(T localValue);
+vector<T,N> QuadReadAcrossX<T, N:int>(vector<T,N> localValue);
+matrix<T,N,M> QuadReadAcrossX<T, N:int, M:int>(matrix<T,N,M> localValue);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `localValue`
+
+--------------------------------------------------------------------------------
+# `QuadReadAcrossY`
+
+## Signature 
+
+```
+T QuadReadAcrossY<T>(T localValue);
+vector<T,N> QuadReadAcrossY<T, N:int>(vector<T,N> localValue);
+matrix<T,N,M> QuadReadAcrossY<T, N:int, M:int>(matrix<T,N,M> localValue);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `localValue`
+
+--------------------------------------------------------------------------------
+# `QuadReadAcrossDiagonal`
+
+## Signature 
+
+```
+T QuadReadAcrossDiagonal<T>(T localValue);
+vector<T,N> QuadReadAcrossDiagonal<T, N:int>(vector<T,N> localValue);
+matrix<T,N,M> QuadReadAcrossDiagonal<T, N:int, M:int>(matrix<T,N,M> localValue);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `localValue`
+
+--------------------------------------------------------------------------------
+# `WaveActiveBitAnd`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveActiveBitAnd<T>(T expr);
+vector<T,N> WaveActiveBitAnd<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveActiveBitAnd<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveActiveBitOr`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveActiveBitOr<T>(T expr);
+vector<T,N> WaveActiveBitOr<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveActiveBitOr<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveActiveBitXor`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveActiveBitXor<T>(T expr);
+vector<T,N> WaveActiveBitXor<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveActiveBitXor<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveActiveMax`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveActiveMax<T>(T expr);
+vector<T,N> WaveActiveMax<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveActiveMax<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveActiveMin`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveActiveMin<T>(T expr);
+vector<T,N> WaveActiveMin<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveActiveMin<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveActiveProduct`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveActiveProduct<T>(T expr);
+vector<T,N> WaveActiveProduct<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveActiveProduct<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveActiveSum`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveActiveSum<T>(T expr);
+vector<T,N> WaveActiveSum<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveActiveSum<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveActiveAllEqual`
+
+## Signature 
+
+```
+/// See Target Availability 1
+bool WaveActiveAllEqual<T>(T value);
+bool WaveActiveAllEqual<T, N:int>(vector<T,N> value);
+/// See Target Availability 2
+bool WaveActiveAllEqual<T, N:int, M:int>(matrix<T,N,M> value);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `value`
+
+--------------------------------------------------------------------------------
+# `WaveActiveAllTrue`
+
+## Signature 
+
+```
+bool WaveActiveAllTrue(bool condition);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `condition`
+
+--------------------------------------------------------------------------------
+# `WaveActiveAnyTrue`
+
+## Signature 
+
+```
+bool WaveActiveAnyTrue(bool condition);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_vote`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `condition`
+
+--------------------------------------------------------------------------------
+# `WaveActiveBallot`
+
+## Signature 
+
+```
+vector<uint,4> WaveActiveBallot(bool condition);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `condition`
+
+--------------------------------------------------------------------------------
+# `WaveActiveCountBits`
+
+## Signature 
+
+```
+uint WaveActiveCountBits(bool value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `WaveGetLaneCount`
+
+## Signature 
+
+```
+uint WaveGetLaneCount();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WaveGetLaneIndex`
+
+## Signature 
+
+```
+uint WaveGetLaneIndex();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WaveIsFirstLane`
+
+## Signature 
+
+```
+bool WaveIsFirstLane();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_basic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `_WaveCountBits`
+
+## Signature 
+
+```
+uint _WaveCountBits(vector<uint,4> value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `WavePrefixProduct`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WavePrefixProduct<T>(T expr);
+vector<T,N> WavePrefixProduct<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WavePrefixProduct<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WavePrefixSum`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WavePrefixSum<T>(T expr);
+vector<T,N> WavePrefixSum<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WavePrefixSum<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveReadLaneFirst`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveReadLaneFirst<T>(T expr);
+vector<T,N> WaveReadLaneFirst<T, N:int>(vector<T,N> expr);
+/// See Target Availability 2
+matrix<T,N,M> WaveReadLaneFirst<T, N:int, M:int>(matrix<T,N,M> expr);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+
+--------------------------------------------------------------------------------
+# `WaveBroadcastLaneAt`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveBroadcastLaneAt<T>(
+    T                    value,
+    int                  lane);
+vector<T,N> WaveBroadcastLaneAt<T, N:int>(
+    vector<T,N>          value,
+    int                  lane);
+/// See Target Availability 2
+matrix<T,N,M> WaveBroadcastLaneAt<T, N:int, M:int>(
+    matrix<T,N,M>        value,
+    int                  lane);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `value`
+* `lane`
+
+--------------------------------------------------------------------------------
+# `WaveReadLaneAt`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveReadLaneAt<T>(
+    T                    value,
+    int                  lane);
+vector<T,N> WaveReadLaneAt<T, N:int>(
+    vector<T,N>          value,
+    int                  lane);
+/// See Target Availability 2
+matrix<T,N,M> WaveReadLaneAt<T, N:int, M:int>(
+    matrix<T,N,M>        value,
+    int                  lane);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `value`
+* `lane`
+
+--------------------------------------------------------------------------------
+# `WaveShuffle`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveShuffle<T>(
+    T                    value,
+    int                  lane);
+vector<T,N> WaveShuffle<T, N:int>(
+    vector<T,N>          value,
+    int                  lane);
+/// See Target Availability 2
+matrix<T,N,M> WaveShuffle<T, N:int, M:int>(
+    matrix<T,N,M>        value,
+    int                  lane);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_shuffle`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `value`
+* `lane`
+
+--------------------------------------------------------------------------------
+# `WavePrefixCountBits`
+
+## Signature 
+
+```
+uint WavePrefixCountBits(bool value);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `value`
+
+--------------------------------------------------------------------------------
+# `WaveGetConvergedMulti`
+
+## Signature 
+
+```
+vector<uint,4> WaveGetConvergedMulti();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WaveGetActiveMulti`
+
+## Signature 
+
+```
+vector<uint,4> WaveGetActiveMulti();
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_ballot`, `SPIR-V 1.3`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WaveMatch`
+
+## Signature 
+
+```
+vector<uint,4> WaveMatch<T>(T value);
+vector<uint,4> WaveMatch<T, N:int>(vector<T,N> value);
+vector<uint,4> WaveMatch<T, N:int, M:int>(matrix<T,N,M> value);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `value`
+
+--------------------------------------------------------------------------------
+# `WaveMultiPrefixCountBits`
+
+## Signature 
+
+```
+uint WaveMultiPrefixCountBits(
+    bool                 value,
+    vector<uint,4>       mask);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `value`
+* `mask`
+
+--------------------------------------------------------------------------------
+# `WaveMultiPrefixBitAnd`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMultiPrefixBitAnd<T>(
+    T                    expr,
+    vector<uint,4>       mask);
+vector<T,N> WaveMultiPrefixBitAnd<T, N:int>(
+    vector<T,N>          expr,
+    vector<uint,4>       mask);
+/// See Target Availability 2
+matrix<T,N,M> WaveMultiPrefixBitAnd<T, N:int, M:int>(
+    matrix<T,N,M>        expr,
+    vector<uint,4>       mask);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+* `mask`
+
+--------------------------------------------------------------------------------
+# `WaveMultiPrefixBitOr`
+
+## Signature 
+
+```
+T WaveMultiPrefixBitOr<T>(
+    T                    expr,
+    vector<uint,4>       mask);
+vector<T,N> WaveMultiPrefixBitOr<T, N:int>(
+    vector<T,N>          expr,
+    vector<uint,4>       mask);
+matrix<T,N,M> WaveMultiPrefixBitOr<T, N:int, M:int>(
+    matrix<T,N,M>        expr,
+    vector<uint,4>       mask);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+* `mask`
+
+--------------------------------------------------------------------------------
+# `WaveMultiPrefixBitXor`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T WaveMultiPrefixBitXor<T>(
+    T                    expr,
+    vector<uint,4>       mask);
+vector<T,N> WaveMultiPrefixBitXor<T, N:int>(
+    vector<T,N>          expr,
+    vector<uint,4>       mask);
+/// See Target Availability 2
+matrix<T,N,M> WaveMultiPrefixBitXor<T, N:int, M:int>(
+    matrix<T,N,M>        expr,
+    vector<uint,4>       mask);
+```
+
+## Requirements
+
+`GLSL GL_KHR_shader_subgroup_arithmetic`, `SPIR-V 1.3`
+
+## Target Availability
+
+1. `CUDA`, `GLSL`, `HLSL`
+2. `CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `expr`
+* `mask`
+
+--------------------------------------------------------------------------------
+# `WaveMultiPrefixProduct`
+
+## Signature 
+
+```
+T WaveMultiPrefixProduct<T>(
+    T                    value,
+    vector<uint,4>       mask);
+vector<T,N> WaveMultiPrefixProduct<T, N:int>(
+    vector<T,N>          value,
+    vector<uint,4>       mask);
+matrix<T,N,M> WaveMultiPrefixProduct<T, N:int, M:int>(
+    matrix<T,N,M>        value,
+    vector<uint,4>       mask);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `value`
+* `mask`
+
+--------------------------------------------------------------------------------
+# `WaveMultiPrefixSum`
+
+## Signature 
+
+```
+T WaveMultiPrefixSum<T>(
+    T                    value,
+    vector<uint,4>       mask);
+vector<T,N> WaveMultiPrefixSum<T, N:int>(
+    vector<T,N>          value,
+    vector<uint,4>       mask);
+matrix<T,N,M> WaveMultiPrefixSum<T, N:int, M:int>(
+    matrix<T,N,M>        value,
+    vector<uint,4>       mask);
+```
+
+## Target Availability
+
+`CUDA`, `HLSL`
+
+## Parameters
+
+* `T`
+* `N`
+* `M`
+* `value`
+* `mask`
+
+--------------------------------------------------------------------------------
+# `struct Buffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `Buffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void Buffer<T>.GetDimensions(out uint dim);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `dim`
+
+--------------------------------------------------------------------------------
+# `Buffer<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T Buffer<T>.Load(int location);
+/// See Target Availability 2
+T Buffer<T>.Load(
+    int                  location,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `Buffer<T>.subscript`
+
+## Signature 
+
+```
+T Buffer<T>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `struct RWBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RWBuffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void RWBuffer<T>.GetDimensions(out uint dim);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `dim`
+
+--------------------------------------------------------------------------------
+# `RWBuffer<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RWBuffer<T>.Load(int location);
+/// See Target Availability 2
+T RWBuffer<T>.Load(
+    int                  location,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RWBuffer<T>.subscript`
+
+## Signature 
+
+```
+T RWBuffer<T>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# `struct RasterizerOrderedBuffer<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+* `Load`
+* `subscript`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedBuffer<T>.GetDimensions`
+
+## Signature 
+
+```
+void RasterizerOrderedBuffer<T>.GetDimensions(out uint dim);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `dim`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedBuffer<T>.Load`
+
+## Signature 
+
+```
+/// See Target Availability 1
+T RasterizerOrderedBuffer<T>.Load(int location);
+/// See Target Availability 2
+T RasterizerOrderedBuffer<T>.Load(
+    int                  location,
+    out uint             status);
+```
+
+## Requirements
+
+`GLSL GL_EXT_samplerless_texture_functions`
+
+## Target Availability
+
+1. `GLSL`, `HLSL`
+2. `HLSL`
+
+## Parameters
+
+* `location`
+* `status`
+
+--------------------------------------------------------------------------------
+# `RasterizerOrderedBuffer<T>.subscript`
+
+## Signature 
+
+```
+T RasterizerOrderedBuffer<T>.subscript(uint index);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `index`
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_NONE
+
+```
+uint RAY_FLAG_NONE
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_FORCE_OPAQUE
+
+```
+uint RAY_FLAG_FORCE_OPAQUE
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_FORCE_NON_OPAQUE
+
+```
+uint RAY_FLAG_FORCE_NON_OPAQUE
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH
+
+```
+uint RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_SKIP_CLOSEST_HIT_SHADER
+
+```
+uint RAY_FLAG_SKIP_CLOSEST_HIT_SHADER
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_CULL_BACK_FACING_TRIANGLES
+
+```
+uint RAY_FLAG_CULL_BACK_FACING_TRIANGLES
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_CULL_FRONT_FACING_TRIANGLES
+
+```
+uint RAY_FLAG_CULL_FRONT_FACING_TRIANGLES
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_CULL_OPAQUE
+
+```
+uint RAY_FLAG_CULL_OPAQUE
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_CULL_NON_OPAQUE
+
+```
+uint RAY_FLAG_CULL_NON_OPAQUE
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_SKIP_TRIANGLES
+
+```
+uint RAY_FLAG_SKIP_TRIANGLES
+```
+
+
+--------------------------------------------------------------------------------
+# RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES
+
+```
+uint RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES
+```
+
+
+--------------------------------------------------------------------------------
+# `struct RayDesc`
+
+## Fields
+
+* `Origin`
+* `TMin`
+* `Direction`
+* `TMax`
+
+--------------------------------------------------------------------------------
+# `struct RaytracingAccelerationStructure`
+
+
+--------------------------------------------------------------------------------
+# `struct BuiltInTriangleIntersectionAttributes`
+
+## Fields
+
+* `barycentrics`
+
+--------------------------------------------------------------------------------
+# `CallShader`
+
+## Signature 
+
+```
+void CallShader<Payload>(
+    uint                 shaderIndex,
+    inout Payload        payload);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `Payload`
+* `shaderIndex`
+* `payload`
+
+--------------------------------------------------------------------------------
+# `TraceRay`
+
+## Signature 
+
+```
+void TraceRay<payload_t>(
+    RaytracingAccelerationStructure AccelerationStructure,
+    uint                 RayFlags,
+    uint                 InstanceInclusionMask,
+    uint                 RayContributionToHitGroupIndex,
+    uint                 MultiplierForGeometryContributionToHitGroupIndex,
+    uint                 MissShaderIndex,
+    RayDesc              Ray,
+    inout payload_t      Payload);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `payload_t`
+* `AccelerationStructure`
+* `RayFlags`
+* `InstanceInclusionMask`
+* `RayContributionToHitGroupIndex`
+* `MultiplierForGeometryContributionToHitGroupIndex`
+* `MissShaderIndex`
+* `Ray`
+* `Payload`
+
+--------------------------------------------------------------------------------
+# `ReportHit`
+
+## Signature 
+
+```
+bool ReportHit<A>(
+    float                tHit,
+    uint                 hitKind,
+    A                    attributes);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `A`
+* `tHit`
+* `hitKind`
+* `attributes`
+
+--------------------------------------------------------------------------------
+# `IgnoreHit`
+
+## Signature 
+
+```
+void IgnoreHit();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `AcceptHitAndEndSearch`
+
+## Signature 
+
+```
+void AcceptHitAndEndSearch();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `DispatchRaysIndex`
+
+## Signature 
+
+```
+vector<uint,3> DispatchRaysIndex();
+```
+
+## Target Availability
+
+`CUDA`, `GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `DispatchRaysDimensions`
+
+## Signature 
+
+```
+vector<uint,3> DispatchRaysDimensions();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WorldRayOrigin`
+
+## Signature 
+
+```
+vector<float,3> WorldRayOrigin();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WorldRayDirection`
+
+## Signature 
+
+```
+vector<float,3> WorldRayDirection();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayTMin`
+
+## Signature 
+
+```
+float RayTMin();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayTCurrent`
+
+## Signature 
+
+```
+float RayTCurrent();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayFlags`
+
+## Signature 
+
+```
+uint RayFlags();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `InstanceIndex`
+
+## Signature 
+
+```
+uint InstanceIndex();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `InstanceID`
+
+## Signature 
+
+```
+uint InstanceID();
+```
+
+## Target Availability
+
+`HLSL`, `__GLSLRAYTRACING`
+
+
+--------------------------------------------------------------------------------
+# `PrimitiveIndex`
+
+## Signature 
+
+```
+uint PrimitiveIndex();
+```
+
+## Target Availability
+
+`HLSL`, `__GLSLRAYTRACING`
+
+
+--------------------------------------------------------------------------------
+# `ObjectRayOrigin`
+
+## Signature 
+
+```
+vector<float,3> ObjectRayOrigin();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `ObjectRayDirection`
+
+## Signature 
+
+```
+vector<float,3> ObjectRayDirection();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `ObjectToWorld3x4`
+
+## Signature 
+
+```
+matrix<float,3,4> ObjectToWorld3x4();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WorldToObject3x4`
+
+## Signature 
+
+```
+matrix<float,3,4> WorldToObject3x4();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `ObjectToWorld4x3`
+
+## Signature 
+
+```
+matrix<float,4,3> ObjectToWorld4x3();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WorldToObject4x3`
+
+## Signature 
+
+```
+matrix<float,4,3> WorldToObject4x3();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `ObjectToWorld`
+
+## Signature 
+
+```
+matrix<float,3,4> ObjectToWorld();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `WorldToObject`
+
+## Signature 
+
+```
+matrix<float,3,4> WorldToObject();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `HitKind`
+
+## Signature 
+
+```
+uint HitKind();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `GL_NV_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# HIT_KIND_TRIANGLE_FRONT_FACE
+
+```
+uint HIT_KIND_TRIANGLE_FRONT_FACE
+```
+
+
+--------------------------------------------------------------------------------
+# HIT_KIND_TRIANGLE_BACK_FACE
+
+```
+uint HIT_KIND_TRIANGLE_BACK_FACE
+```
+
+
+--------------------------------------------------------------------------------
+# `dot4add_u8packed`
+
+## Signature 
+
+```
+uint dot4add_u8packed(
+    uint                 left,
+    uint                 right,
+    uint                 acc);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `left`
+* `right`
+* `acc`
+
+--------------------------------------------------------------------------------
+# `dot4add_i8packed`
+
+## Signature 
+
+```
+int dot4add_i8packed(
+    uint                 left,
+    uint                 right,
+    int                  acc);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `left`
+* `right`
+* `acc`
+
+--------------------------------------------------------------------------------
+# `dot2add`
+
+## Signature 
+
+```
+float dot2add(
+    vector<float,2>      left,
+    vector<float,2>      right,
+    float                acc);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `left`
+* `right`
+* `acc`
+
+--------------------------------------------------------------------------------
+# `SetMeshOutputCounts`
+
+## Signature 
+
+```
+void SetMeshOutputCounts(
+    uint                 vertexCount,
+    uint                 primitiveCount);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `vertexCount`
+* `primitiveCount`
+
+--------------------------------------------------------------------------------
+# `DispatchMesh`
+
+## Signature 
+
+```
+void DispatchMesh<P>(
+    uint                 threadGroupCountX,
+    uint                 threadGroupCountY,
+    uint                 threadGroupCountZ,
+    P                    meshPayload);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `P`
+* `threadGroupCountX`
+* `threadGroupCountY`
+* `threadGroupCountZ`
+* `meshPayload`
+
+--------------------------------------------------------------------------------
+# `struct SAMPLER_FEEDBACK_MIN_MIP`
+
+*Implements:* `__BuiltinSamplerFeedbackType`
+
+
+--------------------------------------------------------------------------------
+# `struct SAMPLER_FEEDBACK_MIP_REGION_USED`
+
+*Implements:* `__BuiltinSamplerFeedbackType`
+
+
+--------------------------------------------------------------------------------
+# `struct FeedbackTexture2D<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2D<T>.GetDimensions`
+
+## Signature 
+
+```
+void FeedbackTexture2D<T>.GetDimensions(
+    out uint             width,
+    out uint             height);
+void FeedbackTexture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             numberOfLevels);
+void FeedbackTexture2D<T>.GetDimensions(
+    out float            width,
+    out float            height);
+void FeedbackTexture2D<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            numberOfLevels);
+```
+
+## Target Availability
+
+``, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2D<T>.WriteSamplerFeedbackLevel`
+
+## Signature 
+
+```
+void FeedbackTexture2D<T>.WriteSamplerFeedbackLevel<S>(
+    Texture2D            tex,
+    SamplerState         samp,
+    vector<float,2>      location,
+    float                lod);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `tex`
+* `samp`
+* `location`
+* `lod`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2D<T>.WriteSamplerFeedback`
+
+## Signature 
+
+```
+void FeedbackTexture2D<T>.WriteSamplerFeedback<S>(
+    Texture2D            tex,
+    SamplerState         samp,
+    vector<float,2>      location,
+    float                clamp);
+void FeedbackTexture2D<T>.WriteSamplerFeedback<S>(
+    Texture2D            tex,
+    SamplerState         samp,
+    vector<float,2>      location);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `tex`
+* `samp`
+* `location`
+* `clamp`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2D<T>.WriteSamplerFeedbackBias`
+
+## Signature 
+
+```
+void FeedbackTexture2D<T>.WriteSamplerFeedbackBias<S>(
+    Texture2D            tex,
+    SamplerState         samp,
+    vector<float,2>      location,
+    float                bias,
+    float                clamp);
+void FeedbackTexture2D<T>.WriteSamplerFeedbackBias<S>(
+    Texture2D            tex,
+    SamplerState         samp,
+    vector<float,2>      location,
+    float                bias);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `tex`
+* `samp`
+* `location`
+* `bias`
+* `clamp`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2D<T>.WriteSamplerFeedbackGrad`
+
+## Signature 
+
+```
+void FeedbackTexture2D<T>.WriteSamplerFeedbackGrad<S>(
+    Texture2D            tex,
+    SamplerState         samp,
+    vector<float,2>      location,
+    vector<float,2>      ddx,
+    vector<float,2>      ddy,
+    float                clamp);
+void FeedbackTexture2D<T>.WriteSamplerFeedbackGrad<S>(
+    Texture2D            tex,
+    SamplerState         samp,
+    vector<float,2>      location,
+    vector<float,2>      ddx,
+    vector<float,2>      ddy);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `tex`
+* `samp`
+* `location`
+* `ddx`
+* `ddy`
+* `clamp`
+
+--------------------------------------------------------------------------------
+# `struct FeedbackTexture2DArray<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `GetDimensions`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2DArray<T>.GetDimensions`
+
+## Signature 
+
+```
+void FeedbackTexture2DArray<T>.GetDimensions(
+    out uint             width,
+    out uint             height,
+    out uint             elements);
+void FeedbackTexture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out uint             width,
+    out uint             height,
+    out uint             elements,
+    out uint             numberOfLevels);
+void FeedbackTexture2DArray<T>.GetDimensions(
+    out float            width,
+    out float            height,
+    out float            elements);
+void FeedbackTexture2DArray<T>.GetDimensions(
+    uint                 mipLevel,
+    out float            width,
+    out float            height,
+    out float            elements,
+    out float            numberOfLevels);
+```
+
+## Target Availability
+
+``, `HLSL`
+
+## Parameters
+
+* `width`
+* `height`
+* `elements`
+* `mipLevel`
+* `numberOfLevels`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2DArray<T>.WriteSamplerFeedbackLevel`
+
+## Signature 
+
+```
+void FeedbackTexture2DArray<T>.WriteSamplerFeedbackLevel<S>(
+    Texture2DArray       texArray,
+    SamplerState         samp,
+    vector<float,3>      location,
+    float                lod);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `texArray`
+* `samp`
+* `location`
+* `lod`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2DArray<T>.WriteSamplerFeedback`
+
+## Signature 
+
+```
+void FeedbackTexture2DArray<T>.WriteSamplerFeedback<S>(
+    Texture2DArray       texArray,
+    SamplerState         samp,
+    vector<float,3>      location,
+    float                clamp);
+void FeedbackTexture2DArray<T>.WriteSamplerFeedback<S>(
+    Texture2DArray       texArray,
+    SamplerState         samp,
+    vector<float,3>      location);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `texArray`
+* `samp`
+* `location`
+* `clamp`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2DArray<T>.WriteSamplerFeedbackBias`
+
+## Signature 
+
+```
+void FeedbackTexture2DArray<T>.WriteSamplerFeedbackBias<S>(
+    Texture2DArray       texArray,
+    SamplerState         samp,
+    vector<float,3>      location,
+    float                bias,
+    float                clamp);
+void FeedbackTexture2DArray<T>.WriteSamplerFeedbackBias<S>(
+    Texture2DArray       texArray,
+    SamplerState         samp,
+    vector<float,3>      location,
+    float                bias);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `texArray`
+* `samp`
+* `location`
+* `bias`
+* `clamp`
+
+--------------------------------------------------------------------------------
+# `FeedbackTexture2DArray<T>.WriteSamplerFeedbackGrad`
+
+## Signature 
+
+```
+void FeedbackTexture2DArray<T>.WriteSamplerFeedbackGrad<S>(
+    Texture2DArray       texArray,
+    SamplerState         samp,
+    vector<float,3>      location,
+    vector<float,3>      ddx,
+    vector<float,3>      ddy,
+    float                clamp);
+void FeedbackTexture2DArray<T>.WriteSamplerFeedbackGrad<S>(
+    Texture2DArray       texArray,
+    SamplerState         samp,
+    vector<float,3>      location,
+    vector<float,3>      ddx,
+    vector<float,3>      ddy);
+```
+
+## Target Availability
+
+`CPP`, `HLSL`
+
+## Parameters
+
+* `S`
+* `texArray`
+* `samp`
+* `location`
+* `ddx`
+* `ddy`
+* `clamp`
+
+--------------------------------------------------------------------------------
+# `GeometryIndex`
+
+## Signature 
+
+```
+uint GeometryIndex();
+```
+
+## Target Availability
+
+`GL_EXT_RAY_TRACING`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# COMMITTED_NOTHING
+
+```
+uint COMMITTED_NOTHING
+```
+
+
+--------------------------------------------------------------------------------
+# COMMITTED_TRIANGLE_HIT
+
+```
+uint COMMITTED_TRIANGLE_HIT
+```
+
+
+--------------------------------------------------------------------------------
+# COMMITTED_PROCEDURAL_PRIMITIVE_HIT
+
+```
+uint COMMITTED_PROCEDURAL_PRIMITIVE_HIT
+```
+
+
+--------------------------------------------------------------------------------
+# CANDIDATE_NON_OPAQUE_TRIANGLE
+
+```
+uint CANDIDATE_NON_OPAQUE_TRIANGLE
+```
+
+
+--------------------------------------------------------------------------------
+# CANDIDATE_PROCEDURAL_PRIMITIVE
+
+```
+uint CANDIDATE_PROCEDURAL_PRIMITIVE
+```
+
+
+--------------------------------------------------------------------------------
+# `struct RayQuery<rayFlags:uint>`
+
+## Generic Parameters
+
+* `rayFlags`
+## Methods
+
+* `init`
+* `TraceRayInline`
+* `Proceed`
+* `Abort`
+* `CandidateType`
+* `CandidateObjectToWorld3x4`
+* `CandidateObjectToWorld4x3`
+* `CandidateWorldToObject3x4`
+* `CandidateWorldToObject4x3`
+* `CandidateInstanceIndex`
+* `CandidateInstanceID`
+* `CandidateGeometryIndex`
+* `CandidatePrimitiveIndex`
+* `CandidateInstanceContributionToHitGroupIndex`
+* `CandidateObjectRayOrigin`
+* `CandidateObjectRayDirection`
+* `CandidateProceduralPrimitiveNonOpaque`
+* `CandidateTriangleFrontFace`
+* `CandidateTriangleBarycentrics`
+* `CandidateTriangleRayT`
+* `CommitNonOpaqueTriangleHit`
+* `CommitProceduralPrimitiveHit`
+* `CommittedStatus`
+* `CommittedObjectToWorld3x4`
+* `CommittedObjectToWorld4x3`
+* `CommittedWorldToObject3x4`
+* `CommittedWorldToObject4x3`
+* `CommittedRayT`
+* `CommittedInstanceIndex`
+* `CommittedInstanceID`
+* `CommittedGeometryIndex`
+* `CommittedPrimitiveIndex`
+* `CommittedInstanceContributionToHitGroupIndex`
+* `CommittedObjectRayOrigin`
+* `CommittedObjectRayDirection`
+* `CommittedTriangleFrontFace`
+* `CommittedTriangleBarycentrics`
+* `RayFlags`
+* `WorldRayOrigin`
+* `WorldRayDirection`
+* `RayTMin`
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.init`
+
+## Signature 
+
+```
+RayQuery<rayFlags:uint>.init();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.TraceRayInline`
+
+## Signature 
+
+```
+void RayQuery<rayFlags:uint>.TraceRayInline(
+    RaytracingAccelerationStructure accelerationStructure,
+    uint                 rayFlags,
+    uint                 instanceInclusionMask,
+    RayDesc              ray);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `accelerationStructure`
+* `rayFlags`
+* `instanceInclusionMask`
+* `ray`
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.Proceed`
+
+## Signature 
+
+```
+bool RayQuery<rayFlags:uint>.Proceed();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.Abort`
+
+## Signature 
+
+```
+void RayQuery<rayFlags:uint>.Abort();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateType`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CandidateType();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateObjectToWorld3x4`
+
+## Signature 
+
+```
+matrix<float,3,4> RayQuery<rayFlags:uint>.CandidateObjectToWorld3x4();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateObjectToWorld4x3`
+
+## Signature 
+
+```
+matrix<float,4,3> RayQuery<rayFlags:uint>.CandidateObjectToWorld4x3();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateWorldToObject3x4`
+
+## Signature 
+
+```
+matrix<float,3,4> RayQuery<rayFlags:uint>.CandidateWorldToObject3x4();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateWorldToObject4x3`
+
+## Signature 
+
+```
+matrix<float,4,3> RayQuery<rayFlags:uint>.CandidateWorldToObject4x3();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateInstanceIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CandidateInstanceIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateInstanceID`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CandidateInstanceID();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateGeometryIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CandidateGeometryIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidatePrimitiveIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CandidatePrimitiveIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateInstanceContributionToHitGroupIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CandidateInstanceContributionToHitGroupIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateObjectRayOrigin`
+
+## Signature 
+
+```
+vector<float,3> RayQuery<rayFlags:uint>.CandidateObjectRayOrigin();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateObjectRayDirection`
+
+## Signature 
+
+```
+vector<float,3> RayQuery<rayFlags:uint>.CandidateObjectRayDirection();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateProceduralPrimitiveNonOpaque`
+
+## Signature 
+
+```
+bool RayQuery<rayFlags:uint>.CandidateProceduralPrimitiveNonOpaque();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateTriangleFrontFace`
+
+## Signature 
+
+```
+bool RayQuery<rayFlags:uint>.CandidateTriangleFrontFace();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateTriangleBarycentrics`
+
+## Signature 
+
+```
+vector<float,2> RayQuery<rayFlags:uint>.CandidateTriangleBarycentrics();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CandidateTriangleRayT`
+
+## Signature 
+
+```
+float RayQuery<rayFlags:uint>.CandidateTriangleRayT();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommitNonOpaqueTriangleHit`
+
+## Signature 
+
+```
+void RayQuery<rayFlags:uint>.CommitNonOpaqueTriangleHit();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommitProceduralPrimitiveHit`
+
+## Signature 
+
+```
+void RayQuery<rayFlags:uint>.CommitProceduralPrimitiveHit(float t);
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+## Parameters
+
+* `t`
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedStatus`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CommittedStatus();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedObjectToWorld3x4`
+
+## Signature 
+
+```
+matrix<float,3,4> RayQuery<rayFlags:uint>.CommittedObjectToWorld3x4();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedObjectToWorld4x3`
+
+## Signature 
+
+```
+matrix<float,4,3> RayQuery<rayFlags:uint>.CommittedObjectToWorld4x3();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedWorldToObject3x4`
+
+## Signature 
+
+```
+matrix<float,3,4> RayQuery<rayFlags:uint>.CommittedWorldToObject3x4();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedWorldToObject4x3`
+
+## Signature 
+
+```
+matrix<float,4,3> RayQuery<rayFlags:uint>.CommittedWorldToObject4x3();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedRayT`
+
+## Signature 
+
+```
+float RayQuery<rayFlags:uint>.CommittedRayT();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedInstanceIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CommittedInstanceIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedInstanceID`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CommittedInstanceID();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedGeometryIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CommittedGeometryIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedPrimitiveIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CommittedPrimitiveIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedInstanceContributionToHitGroupIndex`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.CommittedInstanceContributionToHitGroupIndex();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedObjectRayOrigin`
+
+## Signature 
+
+```
+vector<float,3> RayQuery<rayFlags:uint>.CommittedObjectRayOrigin();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedObjectRayDirection`
+
+## Signature 
+
+```
+vector<float,3> RayQuery<rayFlags:uint>.CommittedObjectRayDirection();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedTriangleFrontFace`
+
+## Signature 
+
+```
+bool RayQuery<rayFlags:uint>.CommittedTriangleFrontFace();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.CommittedTriangleBarycentrics`
+
+## Signature 
+
+```
+vector<float,2> RayQuery<rayFlags:uint>.CommittedTriangleBarycentrics();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.RayFlags`
+
+## Signature 
+
+```
+uint RayQuery<rayFlags:uint>.RayFlags();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.WorldRayOrigin`
+
+## Signature 
+
+```
+vector<float,3> RayQuery<rayFlags:uint>.WorldRayOrigin();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.WorldRayDirection`
+
+## Signature 
+
+```
+vector<float,3> RayQuery<rayFlags:uint>.WorldRayDirection();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `RayQuery<rayFlags:uint>.RayTMin`
+
+## Signature 
+
+```
+float RayQuery<rayFlags:uint>.RayTMin();
+```
+
+## Requirements
+
+`GLSL GL_EXT_ray_query`, `GLSL460`
+
+## Target Availability
+
+`GLSL`, `HLSL`
+
+
+--------------------------------------------------------------------------------
+# `struct VkSubpassInput<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `SubpassLoad`
+
+--------------------------------------------------------------------------------
+# `VkSubpassInput<T>.SubpassLoad`
+
+## Signature 
+
+```
+T VkSubpassInput<T>.SubpassLoad();
+```
+
+## Target Availability
+
+`HLSL`
+
+
+--------------------------------------------------------------------------------
+# `struct VkSubpassInputMS<T>`
+
+## Generic Parameters
+
+* `T`
+## Methods
+
+* `SubpassLoad`
+
+--------------------------------------------------------------------------------
+# `VkSubpassInputMS<T>.SubpassLoad`
+
+## Signature 
+
+```
+T VkSubpassInputMS<T>.SubpassLoad(int sampleIndex);
+```
+
+## Target Availability
+
+`HLSL`
+
+## Parameters
+
+* `sampleIndex`
diff --git a/slang.h b/slang.h
index e0975c853..f0abc135a 100644
--- a/slang.h
+++ b/slang.h
@@ -2959,6 +2959,15 @@ namespace slang
         }
     };
 
+    typedef uint32_t CompileStdLibFlags;
+    struct CompileStdLibFlag
+    {
+        enum Enum : CompileStdLibFlags
+        {
+            WriteDocumentation = 0x1,
+        };
+    };
+
     typedef ISlangBlob IBlob;
 
     struct IComponentType;
@@ -3125,9 +3134,10 @@ namespace slang
 
             /** Compile from (embedded source) the StdLib on the session.
             Will return a failure if there is already a StdLib available
-            NOTE! API is experimental and not ready for production code 
+            NOTE! API is experimental and not ready for production code
+            @param flags to control compilation
             */
-        virtual SLANG_NO_THROW SlangResult SLANG_MCALL compileStdLib() = 0;
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL compileStdLib(CompileStdLibFlags flags) = 0;
 
             /** Load the StdLib. Currently loads modules from the file system. 
             @param stdLib Start address of the serialized stdlib
diff --git a/source/core/slang-list.h b/source/core/slang-list.h
index 42820b492..08d9aa773 100644
--- a/source/core/slang-list.h
+++ b/source/core/slang-list.h
@@ -30,6 +30,8 @@ namespace Slang
         static const Index kInitialCount = 16;
 
     public:
+        typedef List ThisType;
+
         List()
             : m_buffer(nullptr), m_count(0), m_capacity(0)
         {
@@ -185,6 +187,28 @@ namespace Slang
         const T* getBuffer() const { return m_buffer; }
         T* getBuffer() { return m_buffer; }
 
+        bool operator==(const ThisType& rhs) const
+        {
+            if (&rhs == this)
+            {
+                return true;
+            }
+            const Index count = getCount();
+            if (count != rhs.getCount())
+            {
+                return false;
+            }
+            for (Index i = 0; i < count; ++i)
+            {
+                if ((*this)[i] != rhs[i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+        SLANG_FORCE_INLINE bool operator!=(const ThisType& rhs) const { return !(*this == rhs); }
+
         void insert(Index idx, const T& val) { insertRange(idx, &val, 1); }
 
         void insertRange(Index idx, const T* vals, Index n)
diff --git a/source/slang/core.meta.slang b/source/slang/core.meta.slang
index 39ee702c6..6b20dbc3b 100644
--- a/source/slang/core.meta.slang
+++ b/source/slang/core.meta.slang
@@ -27,12 +27,12 @@ syntax globallycoherent : GloballyCoherentModifier;
 ///
 syntax pervertex : PerVertexModifier;
 
-// A type that can be used as an operand for builtins
+/// A type that can be used as an operand for builtins
 [sealed]
 [builtin]
 interface __BuiltinType {}
 
-// A type that can be used for arithmetic operations
+/// A type that can be used for arithmetic operations
 [sealed]
 [builtin]
 interface __BuiltinArithmeticType : __BuiltinType
@@ -41,28 +41,28 @@ interface __BuiltinArithmeticType : __BuiltinType
     __init(int value);
 }
 
-    /// A type that can be used for logical/bitwsie operations
+/// A type that can be used for logical/bitwise operations
 [sealed]
 [builtin]
 interface __BuiltinLogicalType : __BuiltinType {}
 
-// A type that logically has a sign (positive/negative/zero)
+/// A type that logically has a sign (positive/negative/zero)
 [sealed]
 [builtin]
 interface __BuiltinSignedArithmeticType : __BuiltinArithmeticType {}
 
-// A type that can represent integers
+/// A type that can represent integers
 [sealed]
 [builtin]
 interface __BuiltinIntegerType : __BuiltinArithmeticType
 {}
 
-// A type that can represent non-integers
+/// A type that can represent non-integers
 [sealed]
 [builtin]
 interface __BuiltinRealType : __BuiltinSignedArithmeticType {}
 
-// A type that uses a floating-point representation
+/// A type that uses a floating-point representation
 [sealed]
 [builtin]
 interface __BuiltinFloatingPointType : __BuiltinRealType
@@ -74,6 +74,8 @@ interface __BuiltinFloatingPointType : __BuiltinRealType
     static This getPi();
 }
 
+//@ hidden:
+
 // A type resulting from an `enum` declaration.
 [builtin]
 __magic_type(EnumTypeType)
@@ -406,6 +408,8 @@ for (int tt = 0; tt < kTypeCount; ++tt)
 // Declare additional built-in generic types
 }}}}
 
+//@ public:
+
 __generic<T>
 __intrinsic_type($(kIROp_ConstantBufferType))
 __magic_type(ConstantBuffer)
@@ -421,6 +425,8 @@ __intrinsic_type($(kIROp_ParameterBlockType))
 __magic_type(ParameterBlockType)
 struct ParameterBlock {}
 
+//@ hidden:
+
 ${{{{
 
 static const char* kComponentNames[]{ "x", "y", "z", "w" };
@@ -575,6 +581,8 @@ ${{{{
 }}}}
 
 
+//@ public:
+
     /// Sampling state for filtered texture fetches.
 __magic_type(SamplerState, $(int(SamplerStateFlavor::SamplerState)))
 __intrinsic_type($(kIROp_SamplerStateType))
@@ -1554,6 +1562,11 @@ for (int tt = 0; tt < kBaseTextureTypeCount; ++tt)
     }
 }
 
+}}}}
+
+//@ hidden:
+
+${{{{
 
 for (auto op : intrinsicUnaryOps)
 {
@@ -1933,6 +1946,8 @@ ${{{{
 
 }}}}
 
+//@ public:
+
 // Bit cast
 __generic<T, U>
 [__unsafeForceInlineEarly]
@@ -1941,12 +1956,13 @@ T bit_cast(U value);
 
 // Specialized function
 
+/// Given a string returns an integer hash of that string.
 __intrinsic_op
 int getStringHash(String string);
 
-// Use will produce a syntax error in downstream compiler
-// Useful for testing diagnostics around compilation errors of downstream compiler
-// It 'returns' an int so can be used in expressions without the front end complaining.
+/// Use will produce a syntax error in downstream compiler
+/// Useful for testing diagnostics around compilation errors of downstream compiler
+/// It 'returns' an int so can be used in expressions without the front end complaining.
 __target_intrinsic(hlsl, " @ ")
 __target_intrinsic(glsl, " @ ")
 __target_intrinsic(cuda, " @ ")
@@ -1967,6 +1983,8 @@ void endInvocationInterlock() {}
 
 // Operators to apply to `enum` types
 
+//@ hidden:
+
 __generic<E : __EnumType>
 __intrinsic_op($(kIROp_Eql))
 bool operator==(E left, E right);
@@ -1975,6 +1993,8 @@ __generic<E : __EnumType>
 __intrinsic_op($(kIROp_Neq))
 bool operator!=(E left, E right);
 
+//@ public:
+
 // Binding Attributes
 
 __attributeTarget(DeclBase)
diff --git a/source/slang/slang-api.cpp b/source/slang/slang-api.cpp
index 251a3980b..bb0e2e174 100644
--- a/source/slang/slang-api.cpp
+++ b/source/slang/slang-api.cpp
@@ -98,7 +98,7 @@ SLANG_API SlangResult slang_createGlobalSession(
         if (tryLoadStdLibFromCache(globalSession, cacheFilename, dllTimestamp) != SLANG_OK)
         {
             // Compile std lib from embeded source.
-            SLANG_RETURN_ON_FAIL(globalSession->compileStdLib());
+            SLANG_RETURN_ON_FAIL(globalSession->compileStdLib(0));
 
             // Store the compiled stdlib to cache file.
             trySaveStdLibToCache(globalSession, cacheFilename, dllTimestamp);
diff --git a/source/slang/slang-ast-print.cpp b/source/slang/slang-ast-print.cpp
index 29c034659..3ffb481c6 100644
--- a/source/slang/slang-ast-print.cpp
+++ b/source/slang/slang-ast-print.cpp
@@ -34,29 +34,40 @@ void ASTPrinter::addVal(Val* val)
     val->toText(m_builder);
 }
 
-void ASTPrinter::_addDeclName(Decl* decl)
+/* static */void ASTPrinter::appendDeclName(Decl* decl, StringBuilder& out)
 {
     if (as<ConstructorDecl>(decl))
     {
-        m_builder << "init";
+        out << "init";
     }
     else if (as<SubscriptDecl>(decl))
     {
-        m_builder << "subscript";
+        out << "subscript";
     }
     else
     {
-        m_builder << getText(decl->getName());
+        out << getText(decl->getName());
     }
 }
 
+void ASTPrinter::_addDeclName(Decl* decl)
+{
+    appendDeclName(decl, m_builder);
+}
+
+void ASTPrinter::addOverridableDeclPath(const DeclRef<Decl>& declRef)
+{
+    ScopePart scopePart(this, Part::Type::DeclPath);
+    _addDeclPathRec(declRef, 0);
+}
+
 void ASTPrinter::addDeclPath(const DeclRef<Decl>& declRef)
 {
     ScopePart scopePart(this, Part::Type::DeclPath);
-    _addDeclPathRec(declRef);
+    _addDeclPathRec(declRef, 1);
 }
 
-void ASTPrinter::_addDeclPathRec(const DeclRef<Decl>& declRef)
+void ASTPrinter::_addDeclPathRec(const DeclRef<Decl>& declRef, Index depth)
 {
     auto& sb = m_builder;
 
@@ -74,8 +85,48 @@ void ASTPrinter::_addDeclPathRec(const DeclRef<Decl>& declRef)
     // Depending on what the parent is, we may want to format things specially
     if (auto aggTypeDeclRef = parentDeclRef.as<AggTypeDecl>())
     {
-        _addDeclPathRec(aggTypeDeclRef);
-        sb << ".";
+        _addDeclPathRec(aggTypeDeclRef, depth + 1);
+        sb << toSlice(".");
+    }
+    else if (auto namespaceDeclRef = parentDeclRef.as<NamespaceDecl>())
+    {
+        _addDeclPathRec(namespaceDeclRef, depth + 1);
+        // Hmm, it could be argued that we follow the . as seen in AggType as is followed in some other languages
+        // like Java.
+        // That it is useful to have a distinction between something that is a member/method and something that is
+        // in a scope (such as a namespace), and is something that has returned to later languages probably for that
+        // reason (Slang accepts . or ::). So for now this is follows the :: convention.
+        //
+        // It could be argued them that the previous '.' use should vary depending on that distinction.
+        
+        sb << toSlice("::");
+    }
+    else if (auto extensionDeclRef = parentDeclRef.as<ExtensionDecl>())
+    {
+        ExtensionDecl* extensionDecl = as<ExtensionDecl>(parentDeclRef.getDecl());
+        Type* type = extensionDecl->targetType.type;
+        addType(type);
+        sb << toSlice(".");
+    }
+    else if (auto moduleDecl = as<ModuleDecl>(parentDeclRef.getDecl()))
+    {
+        Name* moduleName = moduleDecl->getName();
+        if ((m_optionFlags & OptionFlag::ModuleName) && moduleName)
+        {
+            // Use to say in modules scope
+            sb << moduleName->text << toSlice("::");
+        }
+    }
+
+    // If this decl is the module, we only output it's name if that feature is enabled
+    if (ModuleDecl* moduleDecl = as<ModuleDecl>(declRef.getDecl()))
+    {
+        Name* moduleName = moduleDecl->getName();
+        if ((m_optionFlags & OptionFlag::ModuleName) && moduleName)
+        {
+            sb << moduleName->text; 
+        }
+        return;
     }
 
     _addDeclName(declRef.getDecl());
@@ -85,41 +136,91 @@ void ASTPrinter::_addDeclPathRec(const DeclRef<Decl>& declRef)
     if (parentGenericDeclRef)
     {
         auto genSubst = as<GenericSubstitution>(declRef.substitutions.substitutions);
-        SLANG_RELEASE_ASSERT(genSubst);
-        SLANG_RELEASE_ASSERT(genSubst->genericDecl == parentGenericDeclRef.getDecl());
+        if (genSubst)
+        {
+            SLANG_RELEASE_ASSERT(genSubst);
+            SLANG_RELEASE_ASSERT(genSubst->genericDecl == parentGenericDeclRef.getDecl());
 
-        // If the name we printed previously was an operator
-        // that ends with `<`, then immediately printing the
-        // generic arguments inside `<...>` may cause it to
-        // be hard to parse the operator name visually.
-        //
-        // We thus include a space between the declaration name
-        // and its generic arguments in this case.
-        //
-        if (sb.endsWith("<"))
+            // If the name we printed previously was an operator
+            // that ends with `<`, then immediately printing the
+            // generic arguments inside `<...>` may cause it to
+            // be hard to parse the operator name visually.
+            //
+            // We thus include a space between the declaration name
+            // and its generic arguments in this case.
+            //
+            if (sb.endsWith("<"))
+            {
+                sb << " ";
+            }
+
+            sb << "<";
+            bool first = true;
+            for (auto arg : genSubst->args)
+            {
+                // When printing the representation of a specialized
+                // generic declaration we don't want to include the
+                // argument values for subtype witnesses since these
+                // do not correspond to parameters of the generic
+                // as the user sees it.
+                //
+                if (as<Witness>(arg))
+                    continue;
+
+                if (!first) sb << ", ";
+                addVal(arg);
+                first = false;
+            }
+            sb << ">";
+        }
+        else if (depth > 0)
         {
-            sb << " ";
+            // Write out the generic parameters (only if the depth allows it)
+            addGenericParams(parentGenericDeclRef);
         }
+    }
+}
 
-        sb << "<";
-        bool first = true;
-        for (auto arg : genSubst->args)
+void ASTPrinter::addGenericParams(const DeclRef<GenericDecl>& genericDeclRef)
+{
+    auto& sb = m_builder;
+
+    sb << "<";
+    bool first = true;
+    for (auto paramDeclRef : getMembers(genericDeclRef))
+    {
+        if (auto genericTypeParam = paramDeclRef.as<GenericTypeParamDecl>())
         {
-            // When printing the representation of a specialized
-            // generic declaration we don't want to include the
-            // argument values for subtype witnesses since these
-            // do not correspond to parameters of the generic
-            // as the user sees it.
-            //
-            if (as<Witness>(arg))
-                continue;
+            if (!first) sb << ", ";
+            first = false;
 
+            {
+                ScopePart scopePart(this, Part::Type::GenericParamType);
+                sb << getText(genericTypeParam.getName());
+            }
+        }
+        else if (auto genericValParam = paramDeclRef.as<GenericValueParamDecl>())
+        {
             if (!first) sb << ", ";
-            addVal(arg);
             first = false;
+
+            {
+                ScopePart scopePart(this, Part::Type::GenericParamValue);
+                sb << getText(genericValParam.getName());
+            }
+
+            sb << ":";
+
+            {
+                ScopePart scopePart(this, Part::Type::GenericParamValueType);
+                addType(getType(m_astBuilder, genericValParam));
+            }
+        }
+        else
+        {
         }
-        sb << ">";
     }
+    sb << ">";
 }
 
 void ASTPrinter::addDeclParams(const DeclRef<Decl>& declRef)
@@ -140,6 +241,29 @@ void ASTPrinter::addDeclParams(const DeclRef<Decl>& declRef)
 
             {
                 ScopePart scopePart(this, Part::Type::ParamType);
+
+                // Seems these apply to parameters/VarDeclBase and are not part of the 'type'
+                // but seems more appropriate to put in the Type Part
+
+                if (paramDecl->hasModifier<InOutModifier>())
+                {
+                    sb << toSlice("inout ");
+                }
+                else if (paramDecl->hasModifier<OutModifier>())
+                {
+                    sb << toSlice("out ");
+                }
+                else if (paramDecl->hasModifier<InModifier>())
+                {
+                    sb << toSlice("in ");
+                }
+
+                // And this to params/variables (not the type)
+                if (paramDecl->hasModifier<ConstModifier>())
+                {
+                    sb << toSlice("const ");
+                }
+
                 addType(getType(m_astBuilder, paramDeclRef));
             }
 
@@ -161,42 +285,7 @@ void ASTPrinter::addDeclParams(const DeclRef<Decl>& declRef)
     }
     else if (auto genericDeclRef = declRef.as<GenericDecl>())
     {
-        sb << "<";
-        bool first = true;
-        for (auto paramDeclRef : getMembers(genericDeclRef))
-        {
-            if (auto genericTypeParam = paramDeclRef.as<GenericTypeParamDecl>())
-            {
-                if (!first) sb << ", ";
-                first = false;
-
-                {
-                    ScopePart scopePart(this, Part::Type::GenericParamType);
-                    sb << getText(genericTypeParam.getName());
-                }
-            }
-            else if (auto genericValParam = paramDeclRef.as<GenericValueParamDecl>())
-            {
-                if (!first) sb << ", ";
-                first = false;
-
-                {
-                    ScopePart scopePart(this, Part::Type::GenericParamValue);
-                    sb << getText(genericValParam.getName());
-                }
-
-                sb << ":";
-
-                {
-                    ScopePart scopePart(this, Part::Type::GenericParamValueType);
-                    addType(getType(m_astBuilder, genericValParam));
-                }
-            }
-            else
-            {
-            }
-        }
-        sb << ">";
+        addGenericParams(genericDeclRef);
 
         addDeclParams(DeclRef<Decl>(getInner(genericDeclRef), genericDeclRef.substitutions));
     }
@@ -265,7 +354,7 @@ void ASTPrinter::addDeclResultType(const DeclRef<Decl>& inDeclRef)
     return index >= 0 ? getPart(slice, parts[index]) : UnownedStringSlice();
 }
 
-UnownedStringSlice ASTPrinter::getPart(Part::Type partType) const
+UnownedStringSlice ASTPrinter::getPartSlice(Part::Type partType) const
 {
     return m_parts ? getPart(partType, getSlice(), *m_parts) : UnownedStringSlice();
 }
diff --git a/source/slang/slang-ast-print.h b/source/slang/slang-ast-print.h
index 7fb818898..1c4c20e28 100644
--- a/source/slang/slang-ast-print.h
+++ b/source/slang/slang-ast-print.h
@@ -15,7 +15,8 @@ public:
     {
         enum Enum : OptionFlags
         {
-            ParamNames = 0x1,               ///< If set will output parameter names
+            ParamNames = 0x01,                  ///< If set will output parameter names
+            ModuleName = 0x02,                  ///< Writes out module names
         };
     };
 
@@ -112,6 +113,9 @@ public:
         /// Add the path to the declaration including the declaration name
     void addDeclPath(const DeclRef<Decl>& declRef);
 
+        /// Add the path such that it encapsulates all overridable decls (ie is without terminal generic parameters)
+    void addOverridableDeclPath(const DeclRef<Decl>& declRef);
+
         /// Add just the parameters from a declaration.
         /// Will output the generic parameters (if it's a generic) in <> before the parameters ()
     void addDeclParams(const DeclRef<Decl>& declRef);
@@ -126,15 +130,20 @@ public:
         /// Add the signature for the decl
     void addDeclSignature(const DeclRef<Decl>& declRef);
 
+        /// Add generic parameters 
+    void addGenericParams(const DeclRef<GenericDecl>& genericDeclRef);
+
         /// Get the specified part type. Returns empty slice if not found
-    UnownedStringSlice getPart(Part::Type partType) const;
+    UnownedStringSlice getPartSlice(Part::Type partType) const;
         /// Get the slice for a part
     UnownedStringSlice getPartSlice(const Part& part) const { return getPart(getSlice(), part); }
-    
+
         /// Gets the specified part type
     static UnownedStringSlice getPart(const UnownedStringSlice& slice, const Part& part) { return UnownedStringSlice(slice.begin() + part.start, slice.begin() + part.end); }
     static UnownedStringSlice getPart(Part::Type partType, const UnownedStringSlice& slice, const List<Part>& parts);
 
+    static void appendDeclName(Decl* decl, StringBuilder& out);
+
         /// Ctor
     ASTPrinter(ASTBuilder* astBuilder, OptionFlags optionFlags = 0, List<Part>* parts = nullptr):
         m_astBuilder(astBuilder),
@@ -148,7 +157,7 @@ public:
 
 protected:
 
-    void _addDeclPathRec(const DeclRef<Decl>& declRef);
+    void _addDeclPathRec(const DeclRef<Decl>& declRef, Index depth);
     void _addDeclName(Decl* decl);
     
     OptionFlags m_optionFlags;              ///< Flags controlling output
diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h
index 5eedb4db6..0eb6f992d 100755
--- a/source/slang/slang-compiler.h
+++ b/source/slang/slang-compiler.h
@@ -2176,7 +2176,7 @@ namespace Slang
         SLANG_NO_THROW SlangResult SLANG_MCALL checkCompileTargetSupport(SlangCompileTarget target) override;
         SLANG_NO_THROW SlangResult SLANG_MCALL checkPassThroughSupport(SlangPassThrough passThrough) override;
 
-        SLANG_NO_THROW SlangResult SLANG_MCALL compileStdLib() override;
+        SLANG_NO_THROW SlangResult SLANG_MCALL compileStdLib(slang::CompileStdLibFlags flags) override;
         SLANG_NO_THROW SlangResult SLANG_MCALL loadStdLib(const void* stdLib, size_t stdLibSizeInBytes) override;
         SLANG_NO_THROW SlangResult SLANG_MCALL saveStdLib(SlangArchiveType archiveType, ISlangBlob** outBlob) override;
 
diff --git a/source/slang/slang-doc-extractor.cpp b/source/slang/slang-doc-extractor.cpp
index f44257877..3951e4977 100644
--- a/source/slang/slang-doc-extractor.cpp
+++ b/source/slang/slang-doc-extractor.cpp
@@ -322,6 +322,7 @@ Index DocMarkupExtractor::_findStartIndex(const FindInfo& info, Location locatio
 
         switch (tok.type)
         {
+            case TokenType::LBrace:
             case TokenType::LBracket:
             case TokenType::LParent:
             case TokenType::OpLess:
@@ -396,11 +397,11 @@ Index DocMarkupExtractor::_findStartIndex(const FindInfo& info, Location locatio
                     {
                         return i + 1;
                     }
-                }
 
-                if (location == Location::Before)
-                {
-                    return -1;
+                    if (location == Location::Before)
+                    {
+                        return -1;
+                    }
                 }
 
                 break;
@@ -636,6 +637,9 @@ SlangResult DocMarkupExtractor::_findMarkup(const FindInfo& info, SearchStyle se
             return _findMarkup(info, locs, SLANG_COUNT_OF(locs), out);
         }
         case SearchStyle::Before:
+        {
+            return _findMarkup(info, Location::Before, out);
+        }
         case SearchStyle::Function:
         {
             return _findMarkup(info, Location::Before, out);
@@ -653,6 +657,70 @@ SlangResult DocMarkupExtractor::_findMarkup(const FindInfo& info, SearchStyle se
     }
 }
 
+
+static void _calcLineVisibility(SourceView* sourceView, const TokenList& toks, List<MarkupVisibility>& outLineVisibility)
+{
+    SourceFile* sourceFile = sourceView->getSourceFile();
+    const auto& lineOffsets = sourceFile->getLineBreakOffsets();
+
+    outLineVisibility.setCount(lineOffsets.getCount() + 1);
+
+    MarkupVisibility lastVisibility = MarkupVisibility::Public;
+    Index lastLine = 0;
+
+    for (const auto& tok : toks)
+    {
+        if (tok.type == TokenType::LineComment)
+        {
+            UnownedStringSlice contents = tok.getContent();
+
+            MarkupVisibility newVisibility = lastVisibility;
+
+            // Distinct from other markup
+            if (contents.startsWith(toSlice("//@")))
+            {
+                UnownedStringSlice access = contents.tail(3).trim();
+                if (access == "hidden:" || access == "private:")
+                {
+                    newVisibility = MarkupVisibility::Hidden;
+                }
+                else if (access == "internal:")
+                {
+                    newVisibility = MarkupVisibility::Internal;
+                }
+                else if (access == "public:")
+                {
+                    newVisibility = MarkupVisibility::Public;
+                }
+            }
+
+            if (newVisibility != lastVisibility)
+            {
+                // Work up the line it's on
+                const int offset = sourceView->getRange().getOffset(tok.loc);
+                Index line = sourceFile->calcLineIndexFromOffset(offset);
+
+                // Fill in the span
+                for (Index i = lastLine; i < line; ++i)
+                {
+                    outLineVisibility[i] = lastVisibility;
+                }
+
+                // Record the new access and where we are up to
+                lastLine = line;
+                lastVisibility = newVisibility;
+            }
+        }
+    }
+
+    // Fill in the remaining
+    for (Index i = lastLine; i < outLineVisibility.getCount(); ++ i)
+    {
+        outLineVisibility[i] = lastVisibility;
+    }
+}
+
+
 SlangResult DocMarkupExtractor::extract(const SearchItemInput* inputs, Index inputCount, SourceManager* sourceManager, DiagnosticSink* sink, List<SourceView*>& outViews, List<SearchItemOutput>& out)
 {
     struct Entry
@@ -726,8 +794,10 @@ SlangResult DocMarkupExtractor::extract(const SearchItemInput* inputs, Index inp
 
     {
         TokenList tokens;
+        List<MarkupVisibility> lineVisibility;
+
+        MemoryArena memoryArena(4096);
 
-        MemoryArena memoryArena;
         RootNamePool rootNamePool;
         NamePool namePool;
         namePool.setRootNamePool(&rootNamePool);
@@ -746,6 +816,7 @@ SlangResult DocMarkupExtractor::extract(const SearchItemInput* inputs, Index inp
 
             dst.viewIndex = -1;
             dst.inputIndex = entry.inputIndex;
+            dst.visibilty = MarkupVisibility::Public;
 
             // If there isn't a mechanism to search with, just move on
             if (entry.searchStyle == SearchStyle::None)
@@ -767,6 +838,10 @@ SlangResult DocMarkupExtractor::extract(const SearchItemInput* inputs, Index inp
 
                 // Lex everything
                 tokens = lexer.lexAllTokens();
+
+                // Let's work out the access
+
+                _calcLineVisibility(sourceView, tokens, lineVisibility);
             }
 
             dst.viewIndex = viewIndex;
@@ -781,6 +856,8 @@ SlangResult DocMarkupExtractor::extract(const SearchItemInput* inputs, Index inp
             SourceFile* sourceFile = sourceView->getSourceFile();
             const Index lineIndex = sourceFile->calcLineIndexFromOffset(int(offset));
 
+            dst.visibilty = lineVisibility[lineIndex];
+
             // Okay, lets find the token index with a binary chop
             Index tokenIndex = _findTokenIndex(loc, tokens.m_tokens.getBuffer(), tokens.m_tokens.getCount());
             if (tokenIndex >= 0 && lineIndex >= 0)
@@ -902,6 +979,7 @@ SlangResult DocMarkupExtractor::extract(ModuleDecl* moduleDecl, SourceManager* s
             // Add to the documentation
             DocMarkup::Entry& docEntry = outDoc->addEntry(decl);
             docEntry.m_markup = outputItem.text;
+            docEntry.m_visibility = outputItem.visibilty;
         }
     }
     
diff --git a/source/slang/slang-doc-extractor.h b/source/slang/slang-doc-extractor.h
index ca03fc60b..7a33b390a 100644
--- a/source/slang/slang-doc-extractor.h
+++ b/source/slang/slang-doc-extractor.h
@@ -7,14 +7,22 @@
 
 namespace Slang {
 
+enum class MarkupVisibility : uint8_t
+{
+    Public,                 ///< Always available
+    Internal,               ///< Can be available in more verbose 'internal' documentation
+    Hidden,                 ///< Not generally available
+};
+
 /* Holds the documentation markup that is associated with each node (typically a decl) from a module */
 class DocMarkup : public RefObject
 {
 public:
     struct Entry
     {
-        NodeBase* m_node;           ///< The node this documentation is associated with
-        String m_markup;            ///< The raw contents of of markup associated with the decoration
+        NodeBase* m_node;                                           ///< The node this documentation is associated with
+        String m_markup;                                            ///< The raw contents of of markup associated with the decoration
+        MarkupVisibility m_visibility = MarkupVisibility::Public;   ///< How visible this decl is
     };
 
         /// Adds an entry, returns the reference to pre-existing node if there is one
@@ -149,6 +157,7 @@ public:
         Index viewIndex;                    ///< Index into the array of views on the output
         Index inputIndex;                   ///< The index to this item in the input
         String text;                        ///< The found text
+        MarkupVisibility visibilty;         ///< Visibility of the item
     };
 
     struct FindInfo
diff --git a/source/slang/slang-doc-mark-down.cpp b/source/slang/slang-doc-mark-down.cpp
index 82de7052e..384759474 100644
--- a/source/slang/slang-doc-mark-down.cpp
+++ b/source/slang/slang-doc-mark-down.cpp
@@ -4,9 +4,49 @@
 #include "../core/slang-string-util.h"
 
 #include "slang-ast-builder.h"
+#include "slang-lookup.h"
 
 namespace Slang {
 
+
+struct DocMarkDownWriter::StringListSet
+{
+    Index add(const HashSet<String>& set)
+    {
+        // -1 means empty, which we don't explicitly store
+        Index index = -1;
+        if (set.Count())
+        {
+            List<String> values;
+            for (auto& value : set)
+            {
+                values.add(value);
+            }
+            // Sort so that can be compared for uniqueness
+            values.sort();
+
+            index = m_uniqueValues.indexOf(values);
+            if (index < 0)
+            {
+                index = m_uniqueValues.getCount();
+                m_uniqueValues.add(values);
+            }
+        }
+        m_map.add(index);
+        return index;
+    }
+
+    Index getValueIndex(Index index) const { return m_map[index]; }
+    List<String>& getValuesAt(Index valueIndex) { return m_uniqueValues[valueIndex]; }
+    const List<List<String>>& getUniqueValues() const { return m_uniqueValues; }
+
+    StringListSet() {}
+
+protected:
+    List<Index> m_map;
+    List<List<String>> m_uniqueValues;
+};
+
 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DocMarkDownWriter !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
 
 template <typename T>
@@ -51,39 +91,141 @@ static void _appendAsSingleLine(const UnownedStringSlice& in, StringBuilder& out
     StringUtil::join(lines.getBuffer(), lines.getCount(), ' ', out);
 }
 
-void DocMarkDownWriter::_appendAsBullets(const List<Decl*>& in)
+void DocMarkDownWriter::_appendAsBullets(const List<NameAndText>& values, char wrapChar)
 {
     auto& out = m_builder;
-    for (auto decl : in)
+    for (const auto& value : values)
     {
-        DocMarkup::Entry* paramEntry = m_markup->getEntry(decl);
-
         out << "* ";
 
-        Name* name = decl->getName();
-        if (name)
+        const String& name = value.name;
+        if (name.getLength())
         {
-            out << toSlice("_") << name->text << toSlice("_ ");
+            if (wrapChar)
+            {
+                out.appendChar(wrapChar);
+                out << name;
+                out.appendChar(wrapChar);   
+            }
+            else
+            {
+                out << name;
+            }
         }
 
-        if (paramEntry)
+        if (value.text.getLength())
         {
+            out.appendChar(' ');
+
             // Hmm, we'll want to make something multiline into a single line
-            _appendAsSingleLine(paramEntry->m_markup.getUnownedSlice(), out);
+            _appendAsSingleLine(value.text.getUnownedSlice(), out);
         }
 
         out << "\n";
     }
+}
 
-    out << toSlice("\n");
+void DocMarkDownWriter::_appendAsBullets(const List<String>& values, char wrapChar)
+{
+    auto& out = m_builder;
+    for (const auto& value : values)
+    {
+        out << "* ";
+
+        if (value.getLength())
+        {
+            if (wrapChar)
+            {
+                out.appendChar(wrapChar);
+                out << value;
+                out.appendChar(wrapChar);
+
+            }
+            else
+            {
+                out << value;
+            }
+        }
+        out << "\n";
+    }
 }
 
-template <typename T>
-void DocMarkDownWriter::_appendAsBullets(FilteredMemberList<T>& list)
+String DocMarkDownWriter::_getName(Decl* decl)
 {
-    List<Decl*> decls;
-    _toList(list, decls);
-    _appendAsBullets(decls);
+    StringBuilder buf;
+    ASTPrinter::appendDeclName(decl, buf);
+    return buf.ProduceString();
+}
+
+String DocMarkDownWriter::_getName(InheritanceDecl* decl)
+{
+    StringBuilder buf;
+    buf.Clear();
+    buf << decl->base;
+    return buf.ProduceString();
+}
+
+DocMarkDownWriter::NameAndText DocMarkDownWriter::_getNameAndText(DocMarkup::Entry* entry, Decl* decl)
+{
+    NameAndText nameAndText;
+
+    nameAndText.name = _getName(decl);
+ 
+    // We could extract different text here, but for now just do all markup
+    if (entry)
+    {
+        // For now we'll just use all markup, but really we need something more sophisticated here
+        nameAndText.text = entry->m_markup;
+    }
+
+    return nameAndText;
+}
+
+DocMarkDownWriter::NameAndText DocMarkDownWriter::_getNameAndText(Decl* decl)
+{
+    DocMarkup::Entry* entry = m_markup->getEntry(decl);
+    return _getNameAndText(entry, decl);
+}
+
+List<DocMarkDownWriter::NameAndText> DocMarkDownWriter::_getAsNameAndTextList(const List<Decl*>& in)
+{
+    List<NameAndText> out;
+    for (auto decl : in)
+    {
+        out.add(_getNameAndText(decl));
+    }
+    return out;
+}
+
+List<String> DocMarkDownWriter::_getAsStringList(const List<Decl*>& in)
+{
+    List<String> strings;
+    for (auto decl : in)
+    {
+        strings.add(_getName(decl));
+    }
+    return strings;
+}
+
+void DocMarkDownWriter::_appendCommaList(const List<String>& strings, char wrapChar)
+{
+    for (Index i = 0; i < strings.getCount(); ++i)
+    {
+        if (i > 0)
+        {
+            m_builder << toSlice(", ");
+        }
+        if (wrapChar)
+        {
+            m_builder.appendChar(wrapChar);
+            m_builder << strings[i];
+            m_builder.appendChar(wrapChar);
+        }
+        else
+        {
+            m_builder << strings[i];
+        }
+    }
 }
 
 /* static */void DocMarkDownWriter::getSignature(const List<Part>& parts, Signature& outSig)
@@ -149,73 +291,81 @@ void DocMarkDownWriter::writeVar(const DocMarkup::Entry& entry, VarDecl* varDecl
 
     out << toSlice("```\n");
     out << varDecl->type << toSlice(" ") << varDecl <<  toSlice("\n");
-    out << toSlice("```\n");
+    out << toSlice("```\n\n");
 
     writeDescription(entry);
 }
 
-void DocMarkDownWriter::writeCallable(const DocMarkup::Entry& entry, CallableDecl* callableDecl)
+void DocMarkDownWriter::writeSignature(CallableDecl* callableDecl)
 {
-    writePreamble(entry);
-
     auto& out = m_builder;
 
     List<ASTPrinter::Part> parts;
+   
     ASTPrinter printer(m_astBuilder, ASTPrinter::OptionFlag::ParamNames, &parts);
-
-    GenericDecl* genericDecl = as<GenericDecl>(callableDecl->parentDecl);
-
-    if (genericDecl)
-    {
-        printer.addDeclSignature(DeclRef<Decl>(genericDecl, nullptr));
-    }
-    else
-    {
-        printer.addDeclSignature(DeclRef<Decl>(callableDecl, nullptr));
-    }
+    printer.addDeclSignature(DeclRef<Decl>(callableDecl, nullptr));
 
     Signature signature;
     getSignature(parts, signature);
 
     const Index paramCount = signature.params.getCount();
 
-    // Output the signature
-    {        
-        // Extract the name
-        out << toSlice("# ") << printer.getPartSlice(signature.name) << toSlice("\n\n");
-
-        out << toSlice("## Signature \n");
-        out << toSlice("```\n");
-        out << printer.getPartSlice(signature.returnType) << toSlice(" ");
+    {
+        // Some types (like constructors say) don't have any return type, so check before outputting
+        const UnownedStringSlice returnType = printer.getPartSlice(signature.returnType);
+        if (returnType.getLength() > 0)
+        {
+            out << returnType << toSlice(" ");
+        }
+    }
 
-        out << printer.getPartSlice(signature.name);
+    out << printer.getPartSlice(signature.name);
 
-        if (signature.genericParams.getCount())
+#if 0
+    if (signature.genericParams.getCount())
+    {
+        out << toSlice("<");
+        const Index count = signature.genericParams.getCount();
+        for (Index i = 0; i < count; ++i)
         {
-            out << toSlice("<");
-            const Index count = signature.genericParams.getCount();
-            for (Index i = 0; i < count; ++i)
+            const auto& genericParam = signature.genericParams[i];
+            if (i > 0)
             {
-                const auto& genericParam = signature.genericParams[i];
-                if (i > 0)
-                {
-                    out << toSlice(", ");
-                }
-                out << printer.getPartSlice(genericParam.name);
+                out << toSlice(", ");
+            }
+            out << printer.getPartSlice(genericParam.name);
 
-                if (genericParam.type.type != Part::Type::None)
-                {
-                    out << toSlice(" : ");
-                    out << printer.getPartSlice(genericParam.type);
-                }
+            if (genericParam.type.type != Part::Type::None)
+            {
+                out << toSlice(" : ");
+                out << printer.getPartSlice(genericParam.type);
             }
-            out << toSlice(">");
         }
+        out << toSlice(">");
+    }
+#endif
 
-        if (paramCount > 0)
+    switch (paramCount)
+    {
+        case 0:
         {
+            // Has no parameters
+            out << toSlice("();\n");
+            break;
+        }
+        case 1:
+        {
+            // Place all on single line
+            out.appendChar('(');
+            const auto& param = signature.params[0];
+            out << printer.getPartSlice(param.first) << toSlice(" ") << printer.getPartSlice(param.second);
+            out << ");\n";
+            break;
+        }
+        default:
+        {
+            // Put each parameter on a line on it's own
             out << toSlice("(\n");
-
             StringBuilder line;
             for (Index i = 0; i < paramCount; ++i)
             {
@@ -244,45 +394,371 @@ void DocMarkDownWriter::writeCallable(const DocMarkup::Entry& entry, CallableDec
             }
 
             out << ");\n";
+            break;
+        }
+    }
+}
+
+List<DocMarkDownWriter::NameAndText> DocMarkDownWriter::_getUniqueParams(const List<Decl*>& decls)
+{
+    List<NameAndText> out;
+
+    Dictionary<Name*, Index> nameDict;
+
+    for (auto decl : decls)
+    {
+        Name* name = decl->getName();
+        if (!name)
+        {
+            continue;
+        }
+
+        Index index = nameDict.GetOrAddValue(name, out.getCount());
+
+        if (index >= out.getCount())
+        {
+            out.add(NameAndText{ getText(name), String() });
+        }
+
+        NameAndText& nameAndMarkup = out[index];
+        if (nameAndMarkup.text.getLength() > 0)
+        {
+            continue;
+        }
+
+        auto entry = m_markup->getEntry(decl);
+        if (entry && entry->m_markup.getLength())
+        {
+            nameAndMarkup.text = entry->m_markup;
+        }
+    }
+
+    return out;
+}
+
+static void _addRequirements(Decl* decl, HashSet<String>& outRequirements)
+{
+    StringBuilder buf;
+
+    if (auto spirvRequiredModifier = decl->findModifier<RequiredSPIRVVersionModifier>())
+    {
+        buf.Clear();
+        buf << "SPIR-V ";
+        spirvRequiredModifier->version.append(buf);
+        outRequirements.Add(buf);
+    }
+
+    if (auto glslRequiredModifier = decl->findModifier<RequiredGLSLVersionModifier>())
+    {
+        buf.Clear();
+        buf << "GLSL" << glslRequiredModifier->versionNumberToken.getContent();
+        outRequirements.Add(buf);
+    }
+
+    if (auto cudaSMVersionModifier = decl->findModifier<RequiredCUDASMVersionModifier>())
+    {
+        buf.Clear();
+        buf << "CUDA SM ";
+        cudaSMVersionModifier->version.append(buf);
+        outRequirements.Add(buf);
+    }
+
+    if (auto extensionModifier = decl->findModifier<RequiredGLSLExtensionModifier>())
+    {
+        buf.Clear();
+        buf << "GLSL " << extensionModifier->extensionNameToken.getContent();
+        outRequirements.Add(buf);
+    }
+
+    if (auto requiresNVAPIAttribute = decl->findModifier<RequiresNVAPIAttribute>())
+    {
+        outRequirements.Add("NVAPI");
+    }
+}
+
+void DocMarkDownWriter::_maybeAppendSet(const UnownedStringSlice& title, const StringListSet& set)
+{
+     auto& out = m_builder;
+
+    const auto& uniqueValues = set.getUniqueValues();
+
+    const Index uniqueCount = uniqueValues.getCount();
+    if (uniqueCount > 0 && uniqueValues[0].getCount() > 0)
+    {
+        out << title;
+        if (uniqueCount > 1)
+        {
+            for (Index i = 0; i < uniqueCount; ++i)
+            {
+                out << (i + 1) << (". ");
+                _appendCommaList(uniqueValues[i], '`');
+                out << toSlice("\n");
+            }
         }
         else
         {
-            out << toSlice("();\n");
+            _appendCommaList(uniqueValues[0], '`');
+            out << toSlice("\n");
         }
+        out << toSlice("\n");
+    }
+}
 
-        out << "```\n\n";
+static Decl* _getSameNameDecl(Decl* decl)
+{
+    auto parentDecl = decl->parentDecl;
+
+    // Sanity check: there should always be a parent declaration.
+    //
+    SLANG_ASSERT(parentDecl);
+    if (!parentDecl) return nullptr;
+
+    // If the declaration is the "inner" declaration of a generic,
+    // then we actually want to look one level up, because the
+    // peers/siblings of the declaration will belong to the same
+    // parent as the generic, not to the generic.
+    //
+    if (auto genericParentDecl = as<GenericDecl>(parentDecl))
+    {
+        // Note: we need to check here to be sure `newDecl`
+        // is the "inner" declaration and not one of the
+        // generic parameters, or else we will end up
+        // checking them at the wrong scope.
+        //
+        if (decl == genericParentDecl->inner)
+        {
+            decl = parentDecl;
+        }
     }
 
+    return decl;
+}
+
+static bool _isFirstOverridden(Decl* decl)
+{
+    decl = _getSameNameDecl(decl);
+
+    ContainerDecl* parentDecl = decl->parentDecl;
+
+    // Make sure we have the member dictionary.
+    buildMemberDictionary(parentDecl);
+
+    Name* declName = decl->getName();
+    if (declName)
     {
-        // The parameters, in order
-        List<Decl*> params;
+        Decl** firstDeclPtr = parentDecl->memberDictionary.TryGetValue(declName);
+        return (firstDeclPtr && *firstDeclPtr == decl) || (firstDeclPtr == nullptr);
+    }
 
-        if (genericDecl)
+    return false;
+}
+
+void DocMarkDownWriter::writeCallableOverridable(const DocMarkup::Entry& entry, CallableDecl* callableDecl)
+{
+    auto& out = m_builder;
+
+    writePreamble(entry);
+
+    {
+        // Output the overridable path (ie without terminal generic parameters)
+        ASTPrinter printer(m_astBuilder);
+        printer.addOverridableDeclPath(DeclRef<Decl>(callableDecl, nullptr));
+        // Extract the name
+        out << toSlice("# `") << printer.getStringBuilder() << toSlice("`\n\n");
+    }
+
+    writeDescription(entry);
+
+    List<CallableDecl*> sigs;
+    {
+        Decl* sameNameDecl = _getSameNameDecl(callableDecl);
+
+        for (Decl* curDecl = sameNameDecl; curDecl; curDecl = curDecl->nextInContainerWithSameName)
+        {
+            CallableDecl* sig = nullptr;
+            if (GenericDecl* genericDecl = as<GenericDecl>(curDecl))
+            {
+                sig = as<CallableDecl>(genericDecl->inner);
+            }
+            else
+            {
+                sig = as<CallableDecl>(curDecl);
+            }
+            
+            if (!sig)
+            {
+                continue;
+            }
+
+            // Want to add only the primary sig
+            if (sig->primaryDecl == nullptr || sig->primaryDecl == sig)
+            {
+                sigs.add(sig);
+            }
+        }
+
+        // Lets put back into source order
+        sigs.sort([](CallableDecl* a, CallableDecl* b) -> bool { return a->loc.getRaw() < b->loc.getRaw(); });
+    }
+
+    // Set of sets of requirements, holds index map from addition to the set entry 
+    StringListSet requirementsSetSet;
+
+    // Similarly for targets 
+    StringListSet targetSetSet;
+
+    // We want to determine the unique signature, and then the requirements for the signature
+    {
+        for (Index i = 0; i < sigs.getCount(); ++i)
         {
-            for (Decl* decl : genericDecl->members)
+            CallableDecl* sig = sigs[i];
+            // Add the requirements for all the different versions
             {
-                if (as<GenericTypeParamDecl>(decl) ||
-                    as<GenericValueParamDecl>(decl))
+                HashSet<String> requirementsSet;
+                HashSet<String> targetSet;
+                for (CallableDecl* curSig = sig; curSig; curSig = curSig->nextDecl)
                 {
-                    params.add(decl);
+                    _addRequirements(sig, requirementsSet);
+
+                    // Handle Target info
+
+                    for (auto targetIntrinsic : sig->getModifiersOfType<TargetIntrinsicModifier>())
+                    {
+                        targetSet.Add(String(targetIntrinsic->targetToken.getContent()).toUpper());
+                    }
+                    for (auto specializedForTarget : sig->getModifiersOfType<SpecializedForTargetModifier>())
+                    {
+                        targetSet.Add(String(specializedForTarget->targetToken.getContent()).toUpper());
+                    }
                 }
+                
+                requirementsSetSet.add(requirementsSet);
+
+                // TODO(JS): This really isn't right, we ideally have markup that made hlsl availability explicit
+                // We *assume* that we have 'hlsl' for now
+                targetSet.Add(String("HLSL"));
+                targetSetSet.add(targetSet);
             }
         }
+    }
+    
+    // Output the signature
+    {          
+        out << toSlice("## Signature \n\n");
+        out << toSlice("```\n");
+
+        Index prevRequirementsIndex = -1;
+        Index prevTargetIndex = -1;
 
-        for (ParamDecl* paramDecl : callableDecl->getParameters())
+        const Int sigCount = sigs.getCount();
+        for (Index i = 0; i < sigCount; ++i)
         {
-            params.add(paramDecl);
+            auto sig = sigs[i];
+
+            // Output if needs unique requirements
+            if (requirementsSetSet.getUniqueValues().getCount() > 1)
+            {
+                const Index requirementsIndex = requirementsSetSet.getValueIndex(i);
+                if (requirementsIndex != prevRequirementsIndex)
+                {
+                    if (requirementsIndex >= 0)
+                    {
+                        out << toSlice("/// See Requirement ") << (requirementsIndex + 1) << toSlice("\n");
+                    }
+                    else
+                    {
+                        out << toSlice("/// No requirements\n");
+                    }
+                    prevRequirementsIndex = requirementsIndex;
+                }
+            }
+
+            if (targetSetSet.getUniqueValues().getCount() > 1)
+            {
+                const Index targetIndex = targetSetSet.getValueIndex(i);
+                if (targetIndex != prevTargetIndex)
+                {
+                    if (targetIndex >= 0)
+                    {
+                        out << toSlice("/// See Target Availability ") << (targetIndex + 1) << toSlice("\n");
+                    }
+                    else
+                    {
+                        out << toSlice("/// All Targets\n");
+                    }
+                    prevTargetIndex = targetIndex;
+                }
+            }
+
+            writeSignature(sig);
         }
+        out << "```\n\n";
+    }
 
-        if (params.getCount())
+    _maybeAppendSet(toSlice("## Requirements\n\n"), requirementsSetSet);
+
+    // Target availability
+
+    {
+        const auto& uniqueValues = targetSetSet.getUniqueValues();
+        if (uniqueValues.getCount() == 1 && uniqueValues[0].getCount() == 1 && uniqueValues[0][0] == "hlsl")
         {
-            out << "## Parameters\n\n";
-            // We have generic params and regular parameters, in this list
-            _appendAsBullets(params);
+            // TODO(JS):
+            // If something is marked up for hlsl, and nothing else, that indicates it might *only* be available on hlsl, but
+            // we don't correctly handle that here.
+
+            // If the only thing we have is 'hlsl' - we injected that so we'll *assume* it's available everywhere, so
+            // don't bother outputting.
+        }
+        else
+        {
+            _maybeAppendSet(toSlice("## Target Availability\n\n"), targetSetSet);
         }
     }
 
-    writeDescription(entry);
+    {
+        // We will use the first documentation found for each parameter type
+        {
+            List<Decl*> paramDecls;
+            List<Decl*> genericDecls;
+            for (auto sig : sigs)
+            {
+                GenericDecl* genericDecl = as<GenericDecl>(sig->parentDecl);
+
+                // NOTE!
+                // Here we assume the names of generic parameters are such that they are 
+
+                // We list generic parameters, as types of parameters, if they are directly associated with this
+                // callable.
+                if (genericDecl)
+                {
+                    for (Decl* decl : genericDecl->members)
+                    {
+                        if (as<GenericTypeParamDecl>(decl) ||
+                            as<GenericValueParamDecl>(decl))
+                        {
+                            genericDecls.add(decl);
+                        }
+                    }
+                }
+
+                for (ParamDecl* paramDecl : sig->getParameters())
+                {
+                    paramDecls.add(paramDecl);
+                }
+            }
+
+            if (paramDecls.getCount() > 0 || paramDecls.getCount() > 0)
+            {
+                out << "## Parameters\n\n";
+
+                // Get the unique generics
+                _appendAsBullets(_getUniqueParams(genericDecls), '`');
+                // And parameters
+                _appendAsBullets(_getUniqueParams(paramDecls), '`');
+            }
+        }
+    }
 }
 
 void DocMarkDownWriter::writeEnum(const DocMarkup::Entry& entry, EnumDecl* enumDecl)
@@ -301,12 +777,55 @@ void DocMarkDownWriter::writeEnum(const DocMarkup::Entry& entry, EnumDecl* enumD
 
     out << toSlice("## Values \n\n");
 
-    auto cases = enumDecl->getMembersOfType<EnumCaseDecl>();
-    _appendAsBullets(cases);
-
+    _appendAsBullets(_getAsNameAndTextList(enumDecl->getMembersOfType<EnumCaseDecl>()), '_');
+    
     writeDescription(entry);
 }
 
+void DocMarkDownWriter::_appendEscaped(const UnownedStringSlice& text)
+{
+    auto& out = m_builder;
+
+    const char* start = text.begin();
+    const char* cur = start;
+    const char*const end = text.end();
+
+    for (; cur < end; ++cur)
+    {
+        const char c = *cur;
+
+        switch (c)
+        {
+            case '<':
+            case '>':
+            case '&':
+            case '"':
+            case '_':
+            {
+                // Flush if any before
+                if (cur > start)
+                {
+                    out.append(start, cur);
+                }
+                // Prefix with the 
+                out.appendChar('\\');
+
+                // Start will still include the char, for later flushing
+                start = cur;
+                break;
+            }
+            default: break;
+        }
+    }
+
+    // Flush any remaining
+    if (cur > start)
+    {
+        out.append(start, cur);
+    }
+}
+
+
 void DocMarkDownWriter::_appendDerivedFrom(const UnownedStringSlice& prefix, AggTypeDeclBase* aggTypeDecl)
 {
     auto& out = m_builder;
@@ -330,43 +849,52 @@ void DocMarkDownWriter::_appendDerivedFrom(const UnownedStringSlice& prefix, Agg
     }
 }
 
-void DocMarkDownWriter::writeAggType(const DocMarkup::Entry& entry, AggTypeDeclBase* aggTypeDecl)
+void DocMarkDownWriter::_appendAggTypeName(AggTypeDeclBase* aggTypeDecl)
 {
-    writePreamble(entry);
-
     auto& out = m_builder;
 
     // This could be lots of different things - struct/class/extension/interface/..
 
-    out << toSlice("# ");
+    ASTPrinter printer(m_astBuilder);
+    printer.addDeclPath(DeclRef<Decl>(aggTypeDecl, nullptr));
+
     if (as<StructDecl>(aggTypeDecl))
     {
-        out << toSlice("struct ");
+        out << toSlice("struct ") << printer.getStringBuilder();
     }
     else if (as<ClassDecl>(aggTypeDecl))
     {
-        out << toSlice("class ");
+        out << toSlice("class ") << printer.getStringBuilder();
     }
     else if (as<InterfaceDecl>(aggTypeDecl))
     {
-        out << toSlice("interface ");
+        out << toSlice("interface ") << printer.getStringBuilder();
     }
     else if (ExtensionDecl* extensionDecl = as<ExtensionDecl>(aggTypeDecl))
     {
         out << toSlice("extension ") << extensionDecl->targetType;
-        _appendDerivedFrom(toSlice(" : "), extensionDecl);   
+        _appendDerivedFrom(toSlice(" : "), extensionDecl);
     }
     else
     {
         out << toSlice("?");
     }
+}
 
-    Name* name = aggTypeDecl->getName();
-    if (name)
-    {
-        out << name->text;
-    }
-    out << toSlice("\n\n");
+void DocMarkDownWriter::writeAggType(const DocMarkup::Entry& entry, AggTypeDeclBase* aggTypeDecl)
+{
+    writePreamble(entry);
+
+    auto& out = m_builder;
+
+    // We can write out he name using the printer
+
+    ASTPrinter printer(m_astBuilder);
+    printer.addDeclPath(DeclRef<Decl>(aggTypeDecl, nullptr));
+
+    out << toSlice("# `");
+    _appendAggTypeName(aggTypeDecl);
+    out << toSlice("`\n\n");
 
     {
         List<InheritanceDecl*> inheritanceDecls;
@@ -374,41 +902,104 @@ void DocMarkDownWriter::writeAggType(const DocMarkup::Entry& entry, AggTypeDeclB
 
         if (inheritanceDecls.getCount())
         {
-            out << "*Derives from:* ";
+            out << "*Implements:* ";
+            _appendCommaList(_getAsStringList(inheritanceDecls), '`');
+            out << toSlice("\n\n");
+        }
+    }
 
-            for (Index i = 0; i < inheritanceDecls.getCount(); ++i)
-            {
-                if (i > 0)
+    writeDescription(entry);
+
+    {
+        List<AssocTypeDecl*> assocTypeDecls;
+        _getDecls<AssocTypeDecl>(aggTypeDecl, assocTypeDecls);
+
+        if (assocTypeDecls.getCount())
+        {
+            out << toSlice("# Associated types\n\n");
+
+            for (AssocTypeDecl* assocTypeDecl : assocTypeDecls)
+            {    
+                out << "* _" << assocTypeDecl->getName()->text << "_ ";
+
+                // Look up markup
+                DocMarkup::Entry* assocTypeDeclEntry = m_markup->getEntry(assocTypeDecl);
+                if (assocTypeDeclEntry)
                 {
-                    out << toSlice(", ");
+                    _appendAsSingleLine(assocTypeDeclEntry->m_markup.getUnownedSlice(), out);
+                }
+                out << toSlice("\n");
+
+                List<InheritanceDecl*> inheritanceDecls;
+                _getDecls<InheritanceDecl>(assocTypeDecl, inheritanceDecls);
+
+                if (inheritanceDecls.getCount())
+                {
+                    out << "  ";
+                    _appendCommaList(_getAsStringList(inheritanceDecls), '`');
+                    out << toSlice("\n");
                 }
-                out << inheritanceDecls[i]->base;
             }
+
             out << toSlice("\n\n");
         }
     }
 
+    if (GenericDecl* genericDecl = as<GenericDecl>(aggTypeDecl->parentDecl))
+    {
+        // The parameters, in order
+        List<Decl*> params;
+        for (Decl* decl : genericDecl->members)
+        {
+            if (as<GenericTypeParamDecl>(decl) ||
+                as<GenericValueParamDecl>(decl))
+            {
+                params.add(decl);
+            }
+        }
+    
+        if (params.getCount())
+        {
+            out << "## Generic Parameters\n\n";
+            _appendAsBullets(_getAsNameAndTextList(params), '`');
+        }
+    }
+
     {
         List<Decl*> fields;
         _getDeclsOfType<VarDecl>(aggTypeDecl, fields);
         if (fields.getCount())
         {
             out << "## Fields\n\n";
-            _appendAsBullets(fields);
+
+            _appendAsBullets(_getAsNameAndTextList(fields), '`');
         }
     }
 
     {
-        List<Decl*> methods;
-        _getDeclsOfType<CallableDecl>(aggTypeDecl, methods);
-        if (methods.getCount())
+        // Make sure we've got a query-able member dictionary
+        buildMemberDictionary(aggTypeDecl);
+        SLANG_ASSERT(aggTypeDecl->isMemberDictionaryValid());
+
+        List<Decl*> uniqueMethods;
+        for (const auto& pair : aggTypeDecl->memberDictionary)
         {
+            CallableDecl* callableDecl = as<CallableDecl>(pair.Value);
+            if (callableDecl && isVisible(callableDecl))
+            {
+                uniqueMethods.add(callableDecl);
+            }
+        }
+
+        if (uniqueMethods.getCount())
+        {
+            // Put in source definition order
+            uniqueMethods.sort([](Decl* a, Decl* b) -> bool { return a->loc.getRaw() < b->loc.getRaw(); });
+
             out << "## Methods\n\n";
-            _appendAsBullets(methods);
+            _appendAsBullets(_getAsStringList(uniqueMethods), '`');
         }
     }
-
-    writeDescription(entry);
 }
 
 void DocMarkDownWriter::writePreamble(const DocMarkup::Entry& entry)
@@ -421,26 +1012,40 @@ void DocMarkDownWriter::writePreamble(const DocMarkup::Entry& entry)
     out << toSlice("\n");
 }
 
-
 void DocMarkDownWriter::writeDescription(const DocMarkup::Entry& entry)
 {
     auto& out = m_builder;
 
-    out << toSlice("\n## Description\n\n");
-    out << entry.m_markup;
+    if (entry.m_markup.getLength() > 0)
+    {
+        out << toSlice("## Description\n\n");
+
+        out << entry.m_markup.getUnownedSlice();
+#if 0
+        UnownedStringSlice text(entry.m_markup.getUnownedSlice()), line;
+        while (StringUtil::extractLine(text, line))
+        {
+            out << line << toSlice("\n");
+        }
+#endif
+        out << toSlice("\n");
+    }
 }
 
 void DocMarkDownWriter::writeDecl(const DocMarkup::Entry& entry, Decl* decl)
 {
     // Skip these they will be output as part of their respective 'containers'
-    if (as<ParamDecl>(decl) || as<EnumCaseDecl>(decl))
+    if (as<ParamDecl>(decl) || as<EnumCaseDecl>(decl) || as<AssocTypeDecl>(decl) || as<InheritanceDecl>(decl))
     {
         return; 
     }
 
     if (CallableDecl* callableDecl = as<CallableDecl>(decl))
     {
-        writeCallable(entry, callableDecl);
+        if (_isFirstOverridden(callableDecl))
+        {
+             writeCallableOverridable(entry, callableDecl);
+        }
     }
     else if (EnumDecl* enumDecl = as<EnumDecl>(decl))
     {
@@ -452,6 +1057,12 @@ void DocMarkDownWriter::writeDecl(const DocMarkup::Entry& entry, Decl* decl)
     }
     else if (VarDecl* varDecl = as<VarDecl>(decl))
     {
+        // If part of aggregate type will be output there.
+        if (as<AggTypeDecl>(varDecl->parentDecl))
+        {
+            return;
+        }
+
         writeVar(entry, varDecl);
     }
     else if (as<GenericDecl>(decl))
@@ -460,14 +1071,41 @@ void DocMarkDownWriter::writeDecl(const DocMarkup::Entry& entry, Decl* decl)
     }
 }
 
+bool DocMarkDownWriter::isVisible(const Name* name)
+{
+    return name == nullptr || !name->text.startsWith(toSlice("__"));
+}
+
+bool DocMarkDownWriter::isVisible(const DocMarkup::Entry& entry)
+{
+    // For now if it's not public it's not visible
+    if (entry.m_visibility != MarkupVisibility::Public)
+    {
+        return false;
+    }
+
+    Decl* decl = as<Decl>(entry.m_node);
+    return decl == nullptr || isVisible(decl->getName());
+}
+
+bool DocMarkDownWriter::isVisible(Decl* decl)
+{
+    if (!isVisible(decl->getName()))
+    {
+        return false;
+    }
+
+    auto entry = m_markup->getEntry(decl);
+    return entry == nullptr || entry->m_visibility == MarkupVisibility::Public;
+}
 
 void DocMarkDownWriter::writeAll()
 {
     for (const auto& entry : m_markup->getEntries())
     {
-        NodeBase* node = entry.m_node;
-        Decl* decl = as<Decl>(node);
-        if (decl)
+        Decl* decl = as<Decl>(entry.m_node);
+    
+        if (decl && isVisible(entry))
         {
             writeDecl(entry, decl);
         }
diff --git a/source/slang/slang-doc-mark-down.h b/source/slang/slang-doc-mark-down.h
index e1728d18a..c42d406dc 100644
--- a/source/slang/slang-doc-mark-down.h
+++ b/source/slang/slang-doc-mark-down.h
@@ -31,7 +31,9 @@ struct DocMarkDownWriter
         /// Write out all documentation to the output buffer
     void writeAll();
 
-    void writeCallable(const DocMarkup::Entry& entry, CallableDecl* callable);
+        /// This will write information about *all* of the overridden versions of a function/method
+    void writeCallableOverridable(const DocMarkup::Entry& entry, CallableDecl* callable);
+
     void writeEnum(const DocMarkup::Entry& entry, EnumDecl* enumDecl);
     void writeAggType(const DocMarkup::Entry& entry, AggTypeDeclBase* aggTypeDecl);
     void writeDecl(const DocMarkup::Entry& entry, Decl* decl);
@@ -39,7 +41,13 @@ struct DocMarkDownWriter
 
     void writePreamble(const DocMarkup::Entry& entry);
     void writeDescription(const DocMarkup::Entry& entry);
-    
+
+    void writeSignature(CallableDecl* callableDecl);
+
+    bool isVisible(const DocMarkup::Entry& entry);
+    bool isVisible(Decl* decl);
+    bool isVisible(const Name* name);
+
         /// Get the output string
     const StringBuilder& getOutput() const { return m_builder; }
 
@@ -50,15 +58,61 @@ struct DocMarkDownWriter
     {
     }
 
+    struct StringListSet;
+    
         /// Given a list of ASTPrinter::Parts, works out the different parts of the sig
     static void getSignature(const List<Part>& parts, Signature& outSig);
 
+    struct NameAndText
+    {
+        String name;
+        String text;
+    };
+
+    List<NameAndText> _getUniqueParams(const List<Decl*>& decls);
+
+    String _getName(Decl* decl);
+    String _getName(InheritanceDecl* decl);
+
+    NameAndText _getNameAndText(DocMarkup::Entry* entry, Decl* decl);
+    NameAndText _getNameAndText(Decl* decl);
+
     template <typename T>
-    void _appendAsBullets(FilteredMemberList<T>& in);
-    void _appendAsBullets(const List<Decl*>& in);
+    List<NameAndText> _getAsNameAndTextList(const FilteredMemberList<T>& in)
+    {
+        List<NameAndText> out;
+        for (auto decl : const_cast<FilteredMemberList<T>&>(in))
+        {
+            out.add(_getNameAndText(decl));
+        }
+        return out;
+    }
+    template <typename T>
+    List<String> _getAsStringList(const List<T*>& in)
+    {
+        List<String> strings;
+        for (auto decl : in)
+        {
+            strings.add(_getName(decl));
+        }
+        return strings;
+    }
+
+    List<NameAndText> _getAsNameAndTextList(const List<Decl*>& in);
+    List<String> _getAsStringList(const List<Decl*>& in);
+
+    void _appendAsBullets(const List<NameAndText>& values, char wrapChar);
+    void _appendAsBullets(const List<String>& values, char wrapChar);
+
+    void _appendCommaList(const List<String>& strings, char wrapChar);
+
+    void _maybeAppendSet(const UnownedStringSlice& title, const StringListSet& set);
 
         /// Appends prefix and the list of types derived from
     void _appendDerivedFrom(const UnownedStringSlice& prefix, AggTypeDeclBase* aggTypeDecl);
+    void _appendEscaped(const UnownedStringSlice& text);
+
+    void _appendAggTypeName(AggTypeDeclBase* aggTypeDecl);
 
     DocMarkup* m_markup;
     ASTBuilder* m_astBuilder;
diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp
index fb7ba79c6..ff7923771 100644
--- a/source/slang/slang-options.cpp
+++ b/source/slang/slang-options.cpp
@@ -437,6 +437,8 @@ struct OptionsParser
         // The default archive type is zip
         SlangArchiveType archiveType = SLANG_ARCHIVE_TYPE_ZIP;
 
+        bool compileStdLib = false;
+        slang::CompileStdLibFlags compileStdLibFlags = 0;
         bool hasLoadedRepro = false;
 
         char const* const* argCursor = &argv[0];
@@ -464,7 +466,7 @@ struct OptionsParser
                 }
                 else if (argStr == "-compile-stdlib")
                 {
-                    SLANG_RETURN_ON_FAIL(session->compileStdLib());
+                    compileStdLib = true;
                 }
                 else if (argStr == "-archive-type")
                 {
@@ -533,6 +535,10 @@ struct OptionsParser
                 }
                 else if (argStr == "-doc")
                 {
+                    // If compiling stdlib is enabled, will write out documentation
+                    compileStdLibFlags |= slang::CompileStdLibFlag::WriteDocumentation;
+
+                    // Enable writing out documentation on the req
                     requestImpl->getFrontEndReq()->shouldDocument = true;
                 }
                 else if (argStr == "-dump-repro")
@@ -1109,6 +1115,11 @@ struct OptionsParser
             }
         }
 
+        if (compileStdLib)
+        {
+            SLANG_RETURN_ON_FAIL(session->compileStdLib(compileStdLibFlags));
+        }
+
         // TODO(JS): This is a restriction because of how setting of state works for load repro
         // If a repro has been loaded, then many of the following options will overwrite
         // what was set up. So for now they are ignored, and only parameters set as part
diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp
index 1820b24e5..de47c48ee 100644
--- a/source/slang/slang.cpp
+++ b/source/slang/slang.cpp
@@ -245,7 +245,7 @@ SlangResult Session::checkPassThroughSupport(SlangPassThrough inPassThrough)
     return checkExternalCompilerSupport(this, PassThroughMode(inPassThrough));
 }
 
-SlangResult Session::compileStdLib()
+SlangResult Session::compileStdLib(slang::CompileStdLibFlags compileFlags)
 {
     if (m_builtinLinkage->mapNameToLoadedModules.Count())
     {
@@ -256,6 +256,43 @@ SlangResult Session::compileStdLib()
     // TODO(JS): Could make this return a SlangResult as opposed to exception
     addBuiltinSource(coreLanguageScope, "core", getCoreLibraryCode());
     addBuiltinSource(hlslLanguageScope, "hlsl", getHLSLLibraryCode());
+
+    if (compileFlags & slang::CompileStdLibFlag::WriteDocumentation)
+    {
+        // Not 100% clear where best to get the ASTBuilder from, but from the linkage shouldn't
+        // cause any problems with scoping
+
+        ASTBuilder* astBuilder = getBuiltinLinkage()->getASTBuilder();
+        SourceManager* sourceManager = getBuiltinSourceManager();
+
+        DiagnosticSink sink(sourceManager, Lexer::sourceLocationLexer);
+
+        List<String> docStrings;
+
+        // For all the modules add their doc output to docStrings
+        for (Module* stdlibModule : stdlibModules)
+        { 
+            RefPtr<DocMarkup> markup(new DocMarkup);
+            DocMarkupExtractor::extract(stdlibModule->getModuleDecl(), sourceManager, &sink, markup);
+
+            DocMarkDownWriter writer(markup, astBuilder);
+            writer.writeAll();
+            docStrings.add(writer.getOutput());
+        }
+
+        // Combine all together in stdlib-doc.md output fiel
+        {
+            String fileName("stdlib-doc.md");
+
+            StreamWriter writer(new FileStream(fileName, FileMode::Create));
+
+            for (auto& docString : docStrings)
+            {
+                writer.Write(docString);
+            }
+        }
+    }
+
     return SLANG_OK;
 }
 
diff --git a/tests/diagnostics/bad-operator-call.slang.expected b/tests/diagnostics/bad-operator-call.slang.expected
index 1dd52587c..6b8f250d3 100644
--- a/tests/diagnostics/bad-operator-call.slang.expected
+++ b/tests/diagnostics/bad-operator-call.slang.expected
@@ -3,36 +3,36 @@ standard error = {
 tests/diagnostics/bad-operator-call.slang(18): error 39999: no overload for '+=' applicable to arguments of type (int, S)
     a += b;
       ^~
-core.meta.slang(1904): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, T) -> matrix<T,R,C>
-core.meta.slang(1896): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
-core.meta.slang(1888): note 39999: candidate: func +=<T, N:int>(vector<T,N>, T) -> vector<T,N>
-core.meta.slang(1880): note 39999: candidate: func +=<T, N:int>(vector<T,N>, vector<T,N>) -> vector<T,N>
-core.meta.slang(1872): note 39999: candidate: func +=<T>(T, T) -> T
+core.meta.slang(1937): note 39999: candidate: func +=<T, R:int, C:int>(out matrix<T,R,C>, T) -> matrix<T,R,C>
+core.meta.slang(1929): note 39999: candidate: func +=<T, R:int, C:int>(out matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
+core.meta.slang(1921): note 39999: candidate: func +=<T, N:int>(out vector<T,N>, T) -> vector<T,N>
+core.meta.slang(1913): note 39999: candidate: func +=<T, N:int>(out vector<T,N>, vector<T,N>) -> vector<T,N>
+core.meta.slang(1905): note 39999: candidate: func +=<T>(out T, T) -> T
 tests/diagnostics/bad-operator-call.slang(20): error 39999: no overload for '+' applicable to arguments of type (int, S)
     a = a + b;
           ^
-core.meta.slang(1710): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
-core.meta.slang(1703): note 39999: candidate: func +(uint, uint) -> uint
-core.meta.slang(1696): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
-core.meta.slang(1689): note 39999: candidate: func +(uint8_t, uint8_t) -> uint8_t
-core.meta.slang(1682): note 39999: candidate: func +(double, double) -> double
-core.meta.slang(1675): note 39999: candidate: func +(float, float) -> float
-core.meta.slang(1668): note 39999: candidate: func +(half, half) -> half
-core.meta.slang(1661): note 39999: candidate: func +(int64_t, int64_t) -> int64_t
-core.meta.slang(1654): note 39999: candidate: func +(int, int) -> int
-core.meta.slang(1647): note 39999: candidate: func +(int16_t, int16_t) -> int16_t
+core.meta.slang(1743): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
+core.meta.slang(1736): note 39999: candidate: func +(uint, uint) -> uint
+core.meta.slang(1729): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
+core.meta.slang(1722): note 39999: candidate: func +(uint8_t, uint8_t) -> uint8_t
+core.meta.slang(1715): note 39999: candidate: func +(double, double) -> double
+core.meta.slang(1708): note 39999: candidate: func +(float, float) -> float
+core.meta.slang(1701): note 39999: candidate: func +(half, half) -> half
+core.meta.slang(1694): note 39999: candidate: func +(int64_t, int64_t) -> int64_t
+core.meta.slang(1687): note 39999: candidate: func +(int, int) -> int
+core.meta.slang(1680): note 39999: candidate: func +(int16_t, int16_t) -> int16_t
 tests/diagnostics/bad-operator-call.slang(20): note 39999: 1 more overload candidates
 tests/diagnostics/bad-operator-call.slang(22): error 39999: no overload for '~' applicable to arguments of type (S)
     a = ~b;
         ^
-slang-stdlib.cpp(1718): note 39999: candidate: func ~(uint64_t) -> uint64_t
-slang-stdlib.cpp(1715): note 39999: candidate: func ~(uint) -> uint
-slang-stdlib.cpp(1712): note 39999: candidate: func ~(uint16_t) -> uint16_t
-slang-stdlib.cpp(1709): note 39999: candidate: func ~(uint8_t) -> uint8_t
-slang-stdlib.cpp(1706): note 39999: candidate: func ~(int64_t) -> int64_t
-slang-stdlib.cpp(1703): note 39999: candidate: func ~(int) -> int
-slang-stdlib.cpp(1700): note 39999: candidate: func ~(int16_t) -> int16_t
-slang-stdlib.cpp(1697): note 39999: candidate: func ~(int8_t) -> int8_t
+core.meta.slang(1629): note 39999: candidate: func ~(uint64_t) -> uint64_t
+core.meta.slang(1626): note 39999: candidate: func ~(uint) -> uint
+core.meta.slang(1623): note 39999: candidate: func ~(uint16_t) -> uint16_t
+core.meta.slang(1620): note 39999: candidate: func ~(uint8_t) -> uint8_t
+core.meta.slang(1617): note 39999: candidate: func ~(int64_t) -> int64_t
+core.meta.slang(1614): note 39999: candidate: func ~(int) -> int
+core.meta.slang(1611): note 39999: candidate: func ~(int16_t) -> int16_t
+core.meta.slang(1608): note 39999: candidate: func ~(int8_t) -> int8_t
 tests/diagnostics/bad-operator-call.slang(27): error 30047: argument passed to parameter '0' must be l-value.
     a += c;
     ^
@@ -40,24 +40,24 @@ tests/diagnostics/bad-operator-call.slang(27): note 30048: argument was implicit
 tests/diagnostics/bad-operator-call.slang(31): error 39999: no overload for '+=' applicable to arguments of type (vector<float,3>, vector<int,4>)
     d += c;
       ^~
-core.meta.slang(1904): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, T) -> matrix<T,R,C>
-core.meta.slang(1896): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
-core.meta.slang(1888): note 39999: candidate: func +=<T, N:int>(vector<T,N>, T) -> vector<T,N>
-core.meta.slang(1880): note 39999: candidate: func +=<T, N:int>(vector<T,N>, vector<T,N>) -> vector<T,N>
-core.meta.slang(1872): note 39999: candidate: func +=<T>(T, T) -> T
+core.meta.slang(1937): note 39999: candidate: func +=<T, R:int, C:int>(out matrix<T,R,C>, T) -> matrix<T,R,C>
+core.meta.slang(1929): note 39999: candidate: func +=<T, R:int, C:int>(out matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
+core.meta.slang(1921): note 39999: candidate: func +=<T, N:int>(out vector<T,N>, T) -> vector<T,N>
+core.meta.slang(1913): note 39999: candidate: func +=<T, N:int>(out vector<T,N>, vector<T,N>) -> vector<T,N>
+core.meta.slang(1905): note 39999: candidate: func +=<T>(out T, T) -> T
 tests/diagnostics/bad-operator-call.slang(33): error 39999: no overload for '+' applicable to arguments of type (vector<int,4>, vector<float,3>)
     d = c + d;
           ^
-core.meta.slang(1715): note 39999: candidate: func +<4>(vector<uint64_t,4>, uint64_t) -> vector<uint64_t,4>
-core.meta.slang(1713): note 39999: candidate: func +<3>(uint64_t, vector<uint64_t,3>) -> vector<uint64_t,3>
-core.meta.slang(1710): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
-core.meta.slang(1708): note 39999: candidate: func +<4>(vector<uint,4>, uint) -> vector<uint,4>
-core.meta.slang(1706): note 39999: candidate: func +<3>(uint, vector<uint,3>) -> vector<uint,3>
-core.meta.slang(1703): note 39999: candidate: func +(uint, uint) -> uint
-core.meta.slang(1701): note 39999: candidate: func +<4>(vector<uint16_t,4>, uint16_t) -> vector<uint16_t,4>
-core.meta.slang(1699): note 39999: candidate: func +<3>(uint16_t, vector<uint16_t,3>) -> vector<uint16_t,3>
-core.meta.slang(1696): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
-core.meta.slang(1694): note 39999: candidate: func +<4>(vector<uint8_t,4>, uint8_t) -> vector<uint8_t,4>
+core.meta.slang(1748): note 39999: candidate: func +<4>(vector<uint64_t,4>, uint64_t) -> vector<uint64_t,4>
+core.meta.slang(1746): note 39999: candidate: func +<3>(uint64_t, vector<uint64_t,3>) -> vector<uint64_t,3>
+core.meta.slang(1743): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
+core.meta.slang(1741): note 39999: candidate: func +<4>(vector<uint,4>, uint) -> vector<uint,4>
+core.meta.slang(1739): note 39999: candidate: func +<3>(uint, vector<uint,3>) -> vector<uint,3>
+core.meta.slang(1736): note 39999: candidate: func +(uint, uint) -> uint
+core.meta.slang(1734): note 39999: candidate: func +<4>(vector<uint16_t,4>, uint16_t) -> vector<uint16_t,4>
+core.meta.slang(1732): note 39999: candidate: func +<3>(uint16_t, vector<uint16_t,3>) -> vector<uint16_t,3>
+core.meta.slang(1729): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
+core.meta.slang(1727): note 39999: candidate: func +<4>(vector<uint8_t,4>, uint8_t) -> vector<uint8_t,4>
 tests/diagnostics/bad-operator-call.slang(33): note 39999: 23 more overload candidates
 }
 standard output = {
diff --git a/tests/doc/doc.slang b/tests/doc/doc.slang
index b983011c5..447b6f6f3 100644
--- a/tests/doc/doc.slang
+++ b/tests/doc/doc.slang
@@ -1,5 +1,50 @@
 //DISABLE_TEST:SIMPLE:-entry computeMain -target spirv -stage compute -doc
 
+void outFunc(out int v)
+{
+    v = 10;
+}
+
+/// Testing out nested generics
+struct ParentStruct<T> ///< Some type
+{
+    /// Testing out a child
+    struct ChildStruct<S> ///< Some other type
+    {
+        /// A useless method hey ho
+        T getValue(S v) { T t; S s; return t; }
+    };
+};
+
+struct GenericStruct<T>
+{
+        /// Let's try a typedef too
+    typedef T Element;
+
+    T getValue() { return value; }
+    
+    T value;
+};
+
+/// A rather silly generic function to test out doc extraction
+T addInts<T : __BuiltinIntegerType,     ///< The type we are operating on 
+    /// Just testing out a 
+    /// non type based generic
+    let U : int,
+    let V : int>    ///< And another one                       
+    (
+    /// CHECKING!!
+    T z,           ///< The Z parameter
+    T b)            ///< The B parameter
+{
+    return z + b;
+}
+
+namespace Hey
+{
+    void doAnotherThing(int a);
+}
+
     /// Let's test indent
     /// 
     /// ```
@@ -14,9 +59,12 @@ RWStructuredBuffer<int> inputBuffer;
 /// An interface to do things
 interface IDoThing
 {
+        /// An associated type
+    associatedtype V;
+    
         /// Add two integers
-    int add(int a,      ///< First parameter 
-        int b           ///< Second parameter
+    V add(V a,      ///< First parameter 
+        V b           ///< Second parameter
     );
     
         /// Subtract
@@ -40,6 +88,8 @@ extension float : IThing
 
 struct Thing : IThing, IDoThing
 {
+    typedef int V;
+    
     int add(int a, int b) { return a + b; }
     int sub(int a, int b ) { return a - b; }
     float getValue() { return 1.0f; }
@@ -86,19 +136,6 @@ int doThing(int a,  ///< a parameter
     return a;
 }
 
-/// A rather silly generic function to test out doc extraction
-T addInts<T : __BuiltinIntegerType,     ///< The type we are operating on 
-    /// Just testing out a 
-    /// non type based generic
-    let U : int,
-    let V : int>    ///< And another one                       
-    (
-    /// CHECKING!!
-    T z,           ///< The Z parameter
-    T b)            ///< The B parameter
-{
-    return z + b;
-}
 
 [numthreads(4, 1, 1)]
 void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)