Update DXR API definitions for final spec. (#659)

* Update DXR API definitions for final spec.

The final version of the DXR API has changed the result type of the `DispatchRaysIndex()` and `DispatchRaysDimensions()` builtins to `uint3` (from `uint2`).

* Add updates for DXR object<->world transformations

The `ObjectToWorld()` and `WorldToObject()` functions were renamed to `ObjectToWorld3x4()` and `WorldToObject3x4()`, resepctively, and then new functions `ObjectToWorld4x3()` and `WorldToObject4x3()` were added to give convenient access to the transpose of these matrices.

(No, I'm not clear on why user's couldn't just call `transpose()`, either)

I've left the old function names in the standard library as forwarding functions just so that we don't break existing DXR code that relied on the old names.

2 files changed, 1438 insertions, 1409 deletions

diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index a9609e13e..5bcff1762 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -1,1405 +1,1419 @@
-// Slang HLSL compatibility library
-
-typedef uint UINT;
-
-__generic<T>
-__magic_type(HLSLAppendStructuredBufferType)
-__intrinsic_type($(kIROp_HLSLAppendStructuredBufferType))
-struct AppendStructuredBuffer
-{
-    void Append(T value);
-
-    void GetDimensions(
-        out uint numStructs,
-        out uint stride);
-};
-
-__magic_type(HLSLByteAddressBufferType)
-__intrinsic_type($(kIROp_HLSLByteAddressBufferType))
-struct ByteAddressBuffer
-{
-    void GetDimensions(
-        out uint dim);
-
-    uint Load(int location);
-    uint Load(int location, out uint status);
-
-    uint2 Load2(int location);
-    uint2 Load2(int location, out uint status);
-
-    uint3 Load3(int location);
-    uint3 Load3(int location, out uint status);
-
-    uint4 Load4(int location);
-    uint4 Load4(int location, out uint status);
-};
-
-__generic<T>
-__magic_type(HLSLStructuredBufferType)
-__intrinsic_type($(kIROp_HLSLStructuredBufferType))
-struct StructuredBuffer
-{
-    void GetDimensions(
-        out uint numStructs,
-        out uint stride);
-
-    T Load(int location);
-    T Load(int location, out uint status);
-
-    __subscript(uint index) -> T { __intrinsic_op(bufferLoad) get; };
-};
-
-__generic<T>
-__magic_type(HLSLConsumeStructuredBufferType)
-__intrinsic_type($(kIROp_HLSLConsumeStructuredBufferType))
-struct ConsumeStructuredBuffer
-{
-    T Consume();
-
-    void GetDimensions(
-        out uint numStructs,
-        out uint stride);
-};
-
-__generic<T, let N : int>
-__magic_type(HLSLInputPatchType)
-__intrinsic_type($(kIROp_HLSLInputPatchType))
-struct InputPatch
-{
-    __subscript(uint index) -> T;
-};
-
-__generic<T, let N : int>
-__magic_type(HLSLOutputPatchType)
-__intrinsic_type($(kIROp_HLSLOutputPatchType))
-struct OutputPatch
-{
-    __subscript(uint index) -> T;
-};
-
-${{{{
-static const struct {
-    IROp op;
-    char const* name;
-} kMutableByteAddressBufferCases[] =
-{
-    { kIROp_HLSLRWByteAddressBufferType,                "RWByteAddressBuffer" },
-    { kIROp_HLSLRasterizerOrderedByteAddressBufferType, "RasterizerOrderedByteAddressBuffer" },
-};
-for(auto item : kMutableByteAddressBufferCases) {
-}}}}
-
-__magic_type(HLSL$(item.name)Type)
-__intrinsic_type($(item.op))
-struct $(item.name)
-{
-    // Note(tfoley): supports alll operations from `ByteAddressBuffer`
-    // TODO(tfoley): can this be made a sub-type?
-
-    void GetDimensions(
-        out uint dim);
-
-    uint Load(int location);
-    uint Load(int location, out uint status);
-
-    uint2 Load2(int location);
-    uint2 Load2(int location, out uint status);
-
-    uint3 Load3(int location);
-    uint3 Load3(int location, out uint status);
-
-    uint4 Load4(int location);
-    uint4 Load4(int location, out uint status);
-
-    // Added operations:
-
-    void InterlockedAdd(
-        UINT dest,
-        UINT value,
-        out UINT original_value);
-    void InterlockedAdd(
-        UINT dest,
-        UINT value);
-
-    void InterlockedAnd(
-        UINT dest,
-        UINT value,
-        out UINT original_value);
-    void InterlockedAnd(
-        UINT dest,
-        UINT value);
-
-    void InterlockedCompareExchange(
-        UINT dest,
-        UINT compare_value,
-        UINT value,
-        out UINT original_value);
-    void InterlockedCompareExchange(
-        UINT dest,
-        UINT compare_value,
-        UINT value);
-
-    void InterlockedCompareStore(
-        UINT dest,
-        UINT compare_value,
-        UINT value);
-    void InterlockedCompareStore(
-        UINT dest,
-        UINT compare_value);
-
-    void InterlockedExchange(
-        UINT dest,
-        UINT value,
-        out UINT original_value);
-    void InterlockedExchange(
-        UINT dest,
-        UINT value);
-
-    void InterlockedMax(
-        UINT dest,
-        UINT value,
-        out UINT original_value);
-    void InterlockedMax(
-        UINT dest,
-        UINT value);
-
-    void InterlockedMin(
-        UINT dest,
-        UINT value,
-        out UINT original_value);
-    void InterlockedMin(
-        UINT dest,
-        UINT value);
-
-    void InterlockedOr(
-        UINT dest,
-        UINT value,
-        out UINT original_value);
-    void InterlockedOr(
-        UINT dest,
-        UINT value);
-
-    void InterlockedXor(
-        UINT dest,
-        UINT value,
-        out UINT original_value);
-    void InterlockedXor(
-        UINT dest,
-        UINT value);
-
-    void Store(
-        uint address,
-        uint value);
-
-    void Store2(
-        uint address,
-        uint2 value);
-
-    void Store3(
-        uint address,
-        uint3 value);
-
-    void Store4(
-        uint address,
-        uint4 value);
-};
-
-${{{{
-}
-}}}}
-
-${{{{
-static const struct {
-    IROp op;
-    char const* name;
-} kMutableStructuredBufferCases[] =
-{
-    { kIROp_HLSLRWStructuredBufferType,                "RWStructuredBuffer" },
-    { kIROp_HLSLRasterizerOrderedStructuredBufferType, "RasterizerOrderedStructuredBuffer" },
-};
-for(auto item : kMutableStructuredBufferCases) {
-}}}}
-
-
-__generic<T>
-__magic_type(HLSL$(item.name)Type)
-__intrinsic_type($(item.op))
-struct $(item.name)
-{
-    uint DecrementCounter();
-
-    void GetDimensions(
-        out uint numStructs,
-        out uint stride);
-
-    uint IncrementCounter();
-
-    T Load(int location);
-    T Load(int location, out uint status);
-
-	__subscript(uint index) -> T
-	{
-        __intrinsic_op(bufferElementRef)
-        ref;
-	}
-};
-
-${{{{
-}
-}}}}
-
-__generic<T>
-__magic_type(HLSLPointStreamType)
-__intrinsic_type($(kIROp_HLSLPointStreamType))
-struct PointStream
-{
-    __target_intrinsic(glsl, "EmitVertex()")
-    void Append(T value);
-
-    __target_intrinsic(glsl, "EndPrimitive()")
-    void RestartStrip();
-};
-
-__generic<T>
-__magic_type(HLSLLineStreamType)
-__intrinsic_type($(kIROp_HLSLLineStreamType))
-struct LineStream
-{
-    __target_intrinsic(glsl, "EmitVertex()")
-    void Append(T value);
-
-    __target_intrinsic(glsl, "EndPrimitive()")
-    void RestartStrip();
-};
-
-__generic<T>
-__magic_type(HLSLTriangleStreamType)
-__intrinsic_type($(kIROp_HLSLTriangleStreamType))
-struct TriangleStream
-{
-    __target_intrinsic(glsl, "EmitVertex()")
-    void Append(T value);
-
-    __target_intrinsic(glsl, "EndPrimitive()")
-    void RestartStrip();
-};
-
-// Note(tfoley): Trying to systematically add all the HLSL builtins
-
-// Try to terminate the current draw or dispatch call (HLSL SM 4.0)
-void abort();
-
-// Absolute value (HLSL SM 1.0)
-__generic<T : __BuiltinSignedArithmeticType> T abs(T x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int> vector<T,N> abs(vector<T,N> x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> matrix<T,N,M> abs(matrix<T,N,M> x);
-
-// Inverse cosine (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> T acos(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> acos(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> acos(matrix<T,N,M> x);
-
-// Test if all components are non-zero (HLSL SM 1.0)
-__generic<T : __BuiltinType> bool all(T x);
-__generic<T : __BuiltinType, let N : int> bool all(vector<T,N> x);
-__generic<T : __BuiltinType, let N : int, let M : int> bool all(matrix<T,N,M> x);
-
-// Barrier for writes to all memory spaces (HLSL SM 5.0)
-void AllMemoryBarrier();
-
-// Thread-group sync and barrier for writes to all memory spaces (HLSL SM 5.0)
-void AllMemoryBarrierWithGroupSync();
-
-// Test if any components is non-zero (HLSL SM 1.0)
-
-__generic<T : __BuiltinType>
-__target_intrinsic(glsl, "bool($0)")
-bool any(T x);
-
-__generic<T : __BuiltinType, let N : int>
-__target_intrinsic(glsl, "any(bvec$N0($0))")
-bool any(vector<T,N> x);
-
-__generic<T : __BuiltinType, let N : int, let M : int>
-// TODO: need to define GLSL mapping
-bool any(matrix<T,N,M> x);
-
-
-// Reinterpret bits as a double (HLSL SM 5.0)
-double asdouble(uint lowbits, uint highbits);
-
-// Reinterpret bits as a float (HLSL SM 4.0)
-float asfloat( int x);
-float asfloat(uint x);
-__generic<let N : int> vector<float,N> asfloat(vector< int,N> x);
-__generic<let N : int> vector<float,N> asfloat(vector<uint,N> x);
-__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix< int,N,M> x);
-__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix<uint,N,M> x);
-
-
-// Inverse sine (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> T asin(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> asin(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> asin(matrix<T,N,M> x);
-
-// Reinterpret bits as an int (HLSL SM 4.0)
-int asint(float x);
-int asint(uint x);
-__generic<let N : int> vector<int,N> asint(vector<float,N> x);
-__generic<let N : int> vector<int,N> asint(vector<uint,N> x);
-__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<float,N,M> x);
-__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<uint,N,M> x);
-
-// Reinterpret bits of double as a uint (HLSL SM 5.0)
-void asuint(double value, out uint lowbits, out uint highbits);
-
-// Reinterpret bits as a uint (HLSL SM 4.0)
-uint asuint(float x);
-uint asuint(int x);
-__generic<let N : int> vector<uint,N> asuint(vector<float,N> x);
-__generic<let N : int> vector<uint,N> asuint(vector<int,N> x);
-__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<float,N,M> x);
-__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<int,N,M> x);
-
-// Inverse tangent (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> T atan(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> atan(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> atan(matrix<T,N,M> x);
-
-__generic<T : __BuiltinFloatingPointType>
-__target_intrinsic(glsl,"atan($0,$1)")
-T atan2(T y, T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__target_intrinsic(glsl,"atan($0,$1)")
-vector<T,N> atan2(vector<T,N> y, vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__target_intrinsic(glsl,"atan($0,$1)")
-matrix<T,N,M> atan2(matrix<T,N,M> y, matrix<T,N,M> x);
-
-// Ceiling (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> T ceil(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> ceil(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> ceil(matrix<T,N,M> x);
-
-
-// Check access status to tiled resource
-bool CheckAccessFullyMapped(uint status);
-
-// Clamp (HLSL SM 1.0)
-__generic<T : __BuiltinArithmeticType> T clamp(T x, T min, T max);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> clamp(vector<T,N> x, vector<T,N> min, vector<T,N> max);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> clamp(matrix<T,N,M> x, matrix<T,N,M> min, matrix<T,N,M> max);
-
-// Clip (discard) fragment conditionally
-__generic<T : __BuiltinFloatingPointType> void clip(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> void clip(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> void clip(matrix<T,N,M> x);
-
-// Cosine
-__generic<T : __BuiltinFloatingPointType> T cos(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> cos(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> cos(matrix<T,N,M> x);
-
-// Hyperbolic cosine
-__generic<T : __BuiltinFloatingPointType> T cosh(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> cosh(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> cosh(matrix<T,N,M> x);
-
-// Population count
-__target_intrinsic(glsl, "bitCount")
-uint countbits(uint value);
-
-// Cross product
-__generic<T : __BuiltinArithmeticType> vector<T,3> cross(vector<T,3> x, vector<T,3> y);
-
-// Convert encoded color
-int4 D3DCOLORtoUBYTE4(float4 x);
-
-// Partial-difference derivatives
-__generic<T : __BuiltinFloatingPointType>
-__target_intrinsic(glsl, dFdx)
-T ddx(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__target_intrinsic(glsl, dFdx)
-vector<T,N> ddx(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__target_intrinsic(glsl, dFdx)
-matrix<T,N,M> ddx(matrix<T,N,M> x);
-
-__generic<T : __BuiltinFloatingPointType>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdxCoarse)
-T ddx_coarse(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdxCoarse)
-vector<T,N> ddx_coarse(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdxCoarse)
-matrix<T,N,M> ddx_coarse(matrix<T,N,M> x);
-
-__generic<T : __BuiltinFloatingPointType>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdxFine)
-T ddx_fine(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdxFine)
-vector<T,N> ddx_fine(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdxFine)
-matrix<T,N,M> ddx_fine(matrix<T,N,M> x);
-
-__generic<T : __BuiltinFloatingPointType>
-__target_intrinsic(glsl, dFdy)
-T ddy(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__target_intrinsic(glsl, dFdy)
-vector<T,N> ddy(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__target_intrinsic(glsl, dFdy)
- matrix<T,N,M> ddy(matrix<T,N,M> x);
-
-__generic<T : __BuiltinFloatingPointType>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdyCoarse)
-T ddy_coarse(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdyCoarse)
-vector<T,N> ddy_coarse(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdyCoarse)
-matrix<T,N,M> ddy_coarse(matrix<T,N,M> x);
-
-__generic<T : __BuiltinFloatingPointType>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdyFine)
-T ddy_fine(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdyFine)
-vector<T,N> ddy_fine(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__glsl_extension(GL_ARB_derivative_control)
-__target_intrinsic(glsl, dFdyFine)
-matrix<T,N,M> ddy_fine(matrix<T,N,M> x);
-
-
-// Radians to degrees
-__generic<T : __BuiltinFloatingPointType> T degrees(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> degrees(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> degrees(matrix<T,N,M> x);
-
-// Matrix determinant
-
-__generic<T : __BuiltinFloatingPointType, let N : int> T determinant(matrix<T,N,N> m);
-
-// Barrier for device memory
-void DeviceMemoryBarrier();
-void DeviceMemoryBarrierWithGroupSync();
-
-// Vector distance
-
-__generic<T : __BuiltinFloatingPointType, let N : int> T distance(vector<T,N> x, vector<T,N> y);
-
-// Vector dot product
-
-__generic<T : __BuiltinArithmeticType, let N : int> T dot(vector<T,N> x, vector<T,N> y);
-
-// Helper for computing distance terms for lighting (obsolete)
-
-__generic<T : __BuiltinFloatingPointType> vector<T,4> dst(vector<T,4> x, vector<T,4> y);
-
-// Error message
-
-// void errorf( string format, ... );
-
-// Attribute evaluation
-
-__generic<T : __BuiltinArithmeticType> T EvaluateAttributeAtCentroid(T x);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> EvaluateAttributeAtCentroid(vector<T,N> x);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> EvaluateAttributeAtCentroid(matrix<T,N,M> x);
-
-__generic<T : __BuiltinArithmeticType> T EvaluateAttributeAtSample(T x, uint sampleindex);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> EvaluateAttributeAtSample(vector<T,N> x, uint sampleindex);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> EvaluateAttributeAtSample(matrix<T,N,M> x, uint sampleindex);
-
-__generic<T : __BuiltinArithmeticType> T EvaluateAttributeSnapped(T x, int2 offset);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> EvaluateAttributeSnapped(vector<T,N> x, int2 offset);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> EvaluateAttributeSnapped(matrix<T,N,M> x, int2 offset);
-
-// Base-e exponent
-__generic<T : __BuiltinFloatingPointType> T exp(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> exp(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> exp(matrix<T,N,M> x);
-
-// Base-2 exponent
-__generic<T : __BuiltinFloatingPointType> T exp2(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> exp2(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> exp2(matrix<T,N,M> x);
-
-// Convert 16-bit float stored in low bits of integer
-float f16tof32(uint value);
-__generic<let N : int> vector<float,N> f16tof32(vector<uint,N> value);
-
-// Convert to 16-bit float stored in low bits of integer
-uint f32tof16(float value);
-__generic<let N : int> vector<uint,N> f32tof16(vector<float,N> value);
-
-// Flip surface normal to face forward, if needed
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> faceforward(vector<T,N> n, vector<T,N> i, vector<T,N> ng);
-
-// Find first set bit starting at high bit and working down
-__target_intrinsic(glsl,"findMSB")
-int firstbithigh(int value);
-
-__target_intrinsic(glsl,"findMSB")
-__generic<let N : int> vector<int,N> firstbithigh(vector<int,N> value);
-
-__target_intrinsic(glsl,"findMSB")
-uint firstbithigh(uint value);
-
-__target_intrinsic(glsl,"findMSB")
-__generic<let N : int> vector<uint,N> firstbithigh(vector<uint,N> value);
-
-// Find first set bit starting at low bit and working up
-__target_intrinsic(glsl,"findLSB")
-int firstbitlow(int value);
-
-__target_intrinsic(glsl,"findLSB")
-__generic<let N : int> vector<int,N> firstbitlow(vector<int,N> value);
-
-__target_intrinsic(glsl,"findLSB")
-uint firstbitlow(uint value);
-
-__target_intrinsic(glsl,"findLSB")
-__generic<let N : int> vector<uint,N> firstbitlow(vector<uint,N> value);
-
-// Floor (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> T floor(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> floor(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> floor(matrix<T,N,M> x);
-
-// Fused multiply-add for doubles
-double fma(double a, double b, double c);
-__generic<let N : int> vector<double, N> fma(vector<double, N> a, vector<double, N> b, vector<double, N> c);
-__generic<let N : int, let M : int> matrix<double,N,M> fma(matrix<double,N,M> a, matrix<double,N,M> b, matrix<double,N,M> c);
-
-// Floating point remainder of x/y
-__generic<T : __BuiltinFloatingPointType> T fmod(T x, T y);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> fmod(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> fmod(matrix<T,N,M> x, matrix<T,N,M> y);
-
-// Fractional part
-__generic<T : __BuiltinFloatingPointType>
-__target_intrinsic(glsl, fract)
-T frac(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__target_intrinsic(glsl, fract)
-vector<T,N> frac(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__target_intrinsic(glsl, fract)
-matrix<T,N,M> frac(matrix<T,N,M> x);
-
-// Split float into mantissa and exponent
-__generic<T : __BuiltinFloatingPointType> T frexp(T x, out T exp);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> frexp(vector<T,N> x, out vector<T,N> exp);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> frexp(matrix<T,N,M> x, out matrix<T,N,M> exp);
-
-// Texture filter width
-__generic<T : __BuiltinFloatingPointType> T fwidth(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> fwidth(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> fwidth(matrix<T,N,M> x);
-
-// Get number of samples in render target
-uint GetRenderTargetSampleCount();
-
-// Get position of given sample
-float2 GetRenderTargetSamplePosition(int Index);
-
-// Group memory barrier
-__target_intrinsic(glsl, "groupMemoryBarrier")
-void GroupMemoryBarrier();
-
-// Note: the unmatched parentheses in the GLSL lowering are
-// to cancel out the parens that the emit logic uses, so that
-// we can emit this as if it were an expression.
-//
-// TODO: investigate whether we can just use "operator comma" here.
-__target_intrinsic(glsl, "groupMemoryBarrier()); (barrier()")
-void GroupMemoryBarrierWithGroupSync();
-
-// Atomics
-
-__target_intrinsic(glsl, "$atomicAdd($A, $1)")
-void InterlockedAdd(__ref  int dest,  int value);
-
-__target_intrinsic(glsl, "$atomicAdd($A, $1)")
-void InterlockedAdd(__ref uint dest, uint value);
-
-__target_intrinsic(glsl, "($2 = $atomicAdd($A, $1))")
-void InterlockedAdd(__ref  int dest,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($2 = $atomicAdd($A, $1))")
-void InterlockedAdd(__ref uint dest, uint value, out uint original_value);
-
-__target_intrinsic(glsl, "$atomicAnd($A, $1)")
-void InterlockedAnd(__ref  int dest,  int value);
-
-__target_intrinsic(glsl, "$atomicAnd($A, $1)")
-void InterlockedAnd(__ref uint dest, uint value);
-
-__target_intrinsic(glsl, "($2 = $atomicAnd($A, $1))")
-void InterlockedAnd(__ref  int dest,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($2 = $atomicAnd($A, $1))")
-void InterlockedAnd(__ref uint dest, uint value, out uint original_value);
-
-__target_intrinsic(glsl, "($3 = $atomicCompSwap($A, $1, $2))")
-void InterlockedCompareExchange(__ref  int dest,  int compare_value,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($3 = $atomicCompSwap($A, $1, $2))")
-void InterlockedCompareExchange(__ref uint dest, uint compare_value, uint value, out uint original_value);
-
-__target_intrinsic(glsl, "$atomicCompSwap($A, $1, $2)")
-void InterlockedCompareStore(__ref  int dest,  int compare_value,  int value);
-
-__target_intrinsic(glsl, "$atomicCompSwap($A, $1, $2)")
-void InterlockedCompareStore(__ref uint dest, uint compare_value, uint value);
-
-__target_intrinsic(glsl, "$atomicExchange($A, $1)")
-void InterlockedExchange(__ref  int dest,  int value);
-
-__target_intrinsic(glsl, "$atomicExchange($A, $1)")
-void InterlockedExchange(__ref uint dest, uint value);
-
-__target_intrinsic(glsl, "($2 = $atomicExchange($A, $1))")
-void InterlockedExchange(__ref  int dest,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($2 = $atomicExchange($A, $1))")
-void InterlockedExchange(__ref uint dest, uint value, out uint original_value);
-
-__target_intrinsic(glsl, "$atomicMax($A, $1)")
-void InterlockedMax(__ref  int dest,  int value);
-
-__target_intrinsic(glsl, "$atomicMax($A, $1)")
-void InterlockedMax(__ref uint dest, uint value);
-
-__target_intrinsic(glsl, "($2 = $atomicMax($A, $1))")
-void InterlockedMax(__ref  int dest,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($2 = $atomicMax($A, $1))")
-void InterlockedMax(__ref uint dest, uint value, out uint original_value);
-
-__target_intrinsic(glsl, "$atomicMin($A, $1)")
-void InterlockedMin(in out  int dest,  int value);
-
-__target_intrinsic(glsl, "$atomicMin($A, $1)")
-void InterlockedMin(in out uint dest, uint value);
-
-__target_intrinsic(glsl, "($2 = $atomicMin($A, $1))")
-void InterlockedMin(in out  int dest,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($2 = $atomicMin($A, $1))")
-void InterlockedMin(in out uint dest, uint value, out uint original_value);
-
-__target_intrinsic(glsl, "$atomicOr($A, $1)")
-void InterlockedOr(__ref  int dest,  int value);
-
-__target_intrinsic(glsl, "$atomicOr($A, $1)")
-void InterlockedOr(__ref uint dest, uint value);
-
-__target_intrinsic(glsl, "($2 = $atomicOr($A, $1))")
-void InterlockedOr(__ref  int dest,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($2 = $atomicOr($A, $1))")
-void InterlockedOr(__ref uint dest, uint value, out uint original_value);
-
-__target_intrinsic(glsl, "$atomicXor($A, $1)")
-void InterlockedXor(__ref  int dest,  int value);
-
-__target_intrinsic(glsl, "$atomicXor($A, $1)")
-void InterlockedXor(__ref uint dest, uint value);
-
-__target_intrinsic(glsl, "($2 = $atomicXor($A, $1))")
-void InterlockedXor(__ref  int dest,  int value, out  int original_value);
-
-__target_intrinsic(glsl, "($2 = $atomicXor($A, $1))")
-void InterlockedXor(__ref uint dest, uint value, out uint original_value);
-
-// Is floating-point value finite?
-__generic<T : __BuiltinFloatingPointType> bool isfinite(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<bool,N> isfinite(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<bool,N,M> isfinite(matrix<T,N,M> x);
-
-// Is floating-point value infinite?
-__generic<T : __BuiltinFloatingPointType> bool isinf(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<bool,N> isinf(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<bool,N,M> isinf(matrix<T,N,M> x);
-
-// Is floating-point value not-a-number?
-__generic<T : __BuiltinFloatingPointType> bool isnan(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<bool,N> isnan(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<bool,N,M> isnan(matrix<T,N,M> x);
-
-// Construct float from mantissa and exponent
-__generic<T : __BuiltinFloatingPointType> T ldexp(T x, T exp);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> ldexp(vector<T,N> x, vector<T,N> exp);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> ldexp(matrix<T,N,M> x, matrix<T,N,M> exp);
-
-// Vector length
-__generic<T : __BuiltinFloatingPointType, let N : int> T length(vector<T,N> x);
-
-// Linear interpolation
-__generic<T : __BuiltinFloatingPointType>
-__target_intrinsic(glsl, mix)
-T lerp(T x, T y, T s);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__target_intrinsic(glsl, mix)
-vector<T,N> lerp(vector<T,N> x, vector<T,N> y, vector<T,N> s);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__target_intrinsic(glsl, mix)
-matrix<T,N,M> lerp(matrix<T,N,M> x, matrix<T,N,M> y, matrix<T,N,M> s);
-
-// Legacy lighting function (obsolete)
-float4 lit(float n_dot_l, float n_dot_h, float m);
-
-// Base-e logarithm
-__generic<T : __BuiltinFloatingPointType> T log(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> log(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> log(matrix<T,N,M> x);
-
-// Base-10 logarithm
-__generic<T : __BuiltinFloatingPointType> T log10(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> log10(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> log10(matrix<T,N,M> x);
-
-// Base-2 logarithm
-__generic<T : __BuiltinFloatingPointType> T log2(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> log2(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> log2(matrix<T,N,M> x);
-
-// multiply-add
-__generic<T : __BuiltinArithmeticType> T mad(T mvalue, T avalue, T bvalue);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> mad(vector<T,N> mvalue, vector<T,N> avalue, vector<T,N> bvalue);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> mad(matrix<T,N,M> mvalue, matrix<T,N,M> avalue, matrix<T,N,M> bvalue);
-
-// maximum
-__generic<T : __BuiltinArithmeticType> T max(T x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> max(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> max(matrix<T,N,M> x, matrix<T,N,M> y);
-
-// minimum
-__generic<T : __BuiltinArithmeticType> T min(T x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> min(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> min(matrix<T,N,M> x, matrix<T,N,M> y);
-
-// split into integer and fractional parts (both with same sign)
-__generic<T : __BuiltinFloatingPointType> T modf(T x, out T ip);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> modf(vector<T,N> x, out vector<T,N> ip);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> modf(matrix<T,N,M> x, out matrix<T,N,M> ip);
-
-// msad4 (whatever that is)
-uint4 msad4(uint reference, uint2 source, uint4 accum);
-
-// General inner products
-
-// scalar-scalar
-__generic<T : __BuiltinArithmeticType> T mul(T x, T y);
-
-// scalar-vector and vector-scalar
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> mul(vector<T,N> x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> mul(T x, vector<T,N> y);
-
-// scalar-matrix and matrix-scalar
-__generic<T : __BuiltinArithmeticType, let N : int, let M :int> matrix<T,N,M> mul(matrix<T,N,M> x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int, let M :int> matrix<T,N,M> mul(T x, matrix<T,N,M> y);
-
-// vector-vector (dot product)
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(dot) T mul(vector<T,N> x, vector<T,N> y);
-
-// vector-matrix
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulVectorMatrix) vector<T,M> mul(vector<T,N> x, matrix<T,N,M> y);
-
-// matrix-vector
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulMatrixVector) vector<T,N> mul(matrix<T,N,M> x, vector<T,M> y);
-
-// matrix-matrix
-__generic<T : __BuiltinArithmeticType, let R : int, let N : int, let C : int> __intrinsic_op(mulMatrixMatrix) matrix<T,R,C> mul(matrix<T,R,N> x, matrix<T,N,C> y);
-
-// noise (deprecated)
-float noise(float x);
-__generic<let N : int> float noise(vector<float, N> x);
-
-/// Indicate that an index may be non-uniform at execution time.
-///
-/// Shader Model 5.1 and 6.x introduce support for dynamic indexing
-/// of arrays of resources, but place the restriction that *by default*
-/// the implementation can assume that any value used as an index into
-/// such arrays will be dynamically uniform across an entire `Draw` or `Dispatch`
-/// (when using instancing, the value must be uniform across all instances;
-/// it does not seem that the restriction extends to draws within a multi-draw).
-///
-/// In order to indicate to the implementation that it cannot make the
-/// uniformity assumption, a shader programmer is required to pass the index
-/// to the `NonUniformResourceIndex` function before using it as an index.
-/// The function superficially acts like an identity function.
-///
-/// Note: a future version of Slang may take responsibility for inserting calls
-/// to this function as necessary in output code, rather than make this
-/// the user's responsibility, so that the default behavior of the language
-/// is more semantically "correct."
-uint NonUniformResourceIndex(uint index);
-int NonUniformResourceIndex(int index);
-
-// Normalize a vector
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> normalize(vector<T,N> x);
-
-// Raise to a power
-__generic<T : __BuiltinFloatingPointType> T pow(T x, T y);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> pow(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> pow(matrix<T,N,M> x, matrix<T,N,M> y);
-
-// Output message
-
-// void printf( string format, ... );
-
-// Tessellation factor fixup routines
-
-void Process2DQuadTessFactorsAvg(
-    in  float4 RawEdgeFactors,
-    in  float2 InsideScale,
-    out float4 RoundedEdgeTessFactors,
-    out float2 RoundedInsideTessFactors,
-    out float2 UnroundedInsideTessFactors);
-
-void Process2DQuadTessFactorsMax(
-    in  float4 RawEdgeFactors,
-    in  float2 InsideScale,
-    out float4 RoundedEdgeTessFactors,
-    out float2 RoundedInsideTessFactors,
-    out float2 UnroundedInsideTessFactors);
-
-void Process2DQuadTessFactorsMin(
-    in  float4 RawEdgeFactors,
-    in  float2 InsideScale,
-    out float4 RoundedEdgeTessFactors,
-    out float2 RoundedInsideTessFactors,
-    out float2 UnroundedInsideTessFactors);
-
-void ProcessIsolineTessFactors(
-    in  float RawDetailFactor,
-    in  float RawDensityFactor,
-    out float RoundedDetailFactor,
-    out float RoundedDensityFactor);
-
-void ProcessQuadTessFactorsAvg(
-    in  float4 RawEdgeFactors,
-    in  float InsideScale,
-    out float4 RoundedEdgeTessFactors,
-    out float2 RoundedInsideTessFactors,
-    out float2 UnroundedInsideTessFactors);
-
-void ProcessQuadTessFactorsMax(
-    in  float4 RawEdgeFactors,
-    in  float InsideScale,
-    out float4 RoundedEdgeTessFactors,
-    out float2 RoundedInsideTessFactors,
-    out float2 UnroundedInsideTessFactors);
-
-void ProcessQuadTessFactorsMin(
-    in  float4 RawEdgeFactors,
-    in  float InsideScale,
-    out float4 RoundedEdgeTessFactors,
-    out float2 RoundedInsideTessFactors,
-    out float2 UnroundedInsideTessFactors);
-
-void ProcessTriTessFactorsAvg(
-    in  float3 RawEdgeFactors,
-    in  float InsideScale,
-    out float3 RoundedEdgeTessFactors,
-    out float RoundedInsideTessFactor,
-    out float UnroundedInsideTessFactor);
-
-void ProcessTriTessFactorsMax(
-    in  float3 RawEdgeFactors,
-    in  float InsideScale,
-    out float3 RoundedEdgeTessFactors,
-    out float RoundedInsideTessFactor,
-    out float UnroundedInsideTessFactor);
-
-void ProcessTriTessFactorsMin(
-    in  float3 RawEdgeFactors,
-    in  float InsideScale,
-    out float3 RoundedEdgeTessFactors,
-    out float RoundedInsideTessFactors,
-    out float UnroundedInsideTessFactors);
-
-// Degrees to radians
-__generic<T : __BuiltinFloatingPointType> T radians(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> radians(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> radians(matrix<T,N,M> x);
-
-// Approximate reciprocal
-__generic<T : __BuiltinFloatingPointType> T rcp(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> rcp(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> rcp(matrix<T,N,M> x);
-
-// Reflect incident vector across plane with given normal
-__generic<T : __BuiltinFloatingPointType, let N : int>
-vector<T,N> reflect(vector<T,N> i, vector<T,N> n);
-
-// Refract incident vector given surface normal and index of refraction
-__generic<T : __BuiltinFloatingPointType, let N : int>
-vector<T,N> refract(vector<T,N> i, vector<T,N> n, float eta);
-
-// Reverse order of bits
-__target_intrinsic(glsl, "bitfieldReverse")
-uint reversebits(uint value);
-
-__target_intrinsic(glsl, "bitfieldReverse")
-__generic<let N : int> vector<uint,N> reversebits(vector<uint,N> value);
-
-// Round-to-nearest
-__generic<T : __BuiltinFloatingPointType> T round(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> round(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> round(matrix<T,N,M> x);
-
-// Reciprocal of square root
-__generic<T : __BuiltinFloatingPointType> T rsqrt(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> rsqrt(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> rsqrt(matrix<T,N,M> x);
-
-// Clamp value to [0,1] range
-__generic<T : __BuiltinFloatingPointType>
-__target_intrinsic(glsl, "clamp($0, 0, 1)")
-T saturate(T x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__target_intrinsic(glsl, "clamp($0, 0, 1)")
-vector<T,N> saturate(vector<T,N> x);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__target_intrinsic(glsl, "clamp($0, 0, 1)")
-matrix<T,N,M> saturate(matrix<T,N,M> x);
-
-__generic<T : __BuiltinFloatingPointType>
-__specialized_for_target(glsl)
-T saturate(T x)
-{
-    return clamp<T>(x, T(0), T(1));
-}
-
-__generic<T : __BuiltinFloatingPointType, let N : int>
-__specialized_for_target(glsl)
-vector<T,N> saturate(vector<T,N> x)
-{
-    return clamp<T,N>(x,
-        vector<T,N>(T(0)),
-        vector<T,N>(T(1)));
-}
-
-// HACK: need a helper to turn a scalar into a matrix,
-// because GLSL and HLSL disagree on the semantics of
-// constructing a matrix from a single scalar.
-__generic<T, let N : int, let M : int>
-matrix<T,N,M> __scalarToMatrix(T value);
-
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__specialized_for_target(glsl)
-matrix<T,N,M> saturate(matrix<T,N,M> x)
-{
-    return clamp<T,N,M>(x,
-        __scalarToMatrix<T,N,M>(T(0)),
-        __scalarToMatrix<T,N,M>(T(1)));
-}
-
-
-// Extract sign of value
-__generic<T : __BuiltinSignedArithmeticType> int sign(T x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int> vector<int,N> sign(vector<T,N> x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> matrix<int,N,M> sign(matrix<T,N,M> x);
-
-
-// Sine
-__generic<T : __BuiltinFloatingPointType> T sin(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> sin(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> sin(matrix<T,N,M> x);
-
-// Sine and cosine
-__generic<T : __BuiltinFloatingPointType, let N : int> void sincos(T x, out T s, out T c);
-__generic<T : __BuiltinFloatingPointType, let N : int> void sincos(vector<T,N> x, out vector<T,N> s, out vector<T,N> c);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> void sincos(matrix<T,N,M> x, out matrix<T,N,M> s, out matrix<T,N,M> c);
-
-// Hyperbolic Sine
-__generic<T : __BuiltinFloatingPointType> T sinh(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> sinh(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> sinh(matrix<T,N,M> x);
-
-// Smooth step (Hermite interpolation)
-__generic<T : __BuiltinFloatingPointType> T smoothstep(T min, T max, T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> smoothstep(vector<T,N> min, vector<T,N> max, vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> smoothstep(matrix<T,N,M> min, matrix<T,N,M> max, matrix<T,N,M> x);
-
-// Square root
-__generic<T : __BuiltinFloatingPointType> T sqrt(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> sqrt(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> sqrt(matrix<T,N,M> x);
-
-// Step function
-__generic<T : __BuiltinFloatingPointType> T step(T y, T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> step(vector<T,N> y, vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> step(matrix<T,N,M> y, matrix<T,N,M> x);
-
-// Tangent
-__generic<T : __BuiltinFloatingPointType> T tan(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> tan(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> tan(matrix<T,N,M> x);
-
-// Hyperbolic tangent
-__generic<T : __BuiltinFloatingPointType> T tanh(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> tanh(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> tanh(matrix<T,N,M> x);
-
-// Legacy texture-fetch operations
-
-/*
-float4 tex1D(sampler1D s, float t);
-float4 tex1D(sampler1D s, float t, float ddx, float ddy);
-float4 tex1Dbias(sampler1D s, float4 t);
-float4 tex1Dgrad(sampler1D s, float t, float ddx, float ddy);
-float4 tex1Dlod(sampler1D s, float4 t);
-float4 tex1Dproj(sampler1D s, float4 t);
-
-float4 tex2D(sampler2D s, float2 t);
-float4 tex2D(sampler2D s, float2 t, float2 ddx, float2 ddy);
-float4 tex2Dbias(sampler2D s, float4 t);
-float4 tex2Dgrad(sampler2D s, float2 t, float2 ddx, float2 ddy);
-float4 tex2Dlod(sampler2D s, float4 t);
-float4 tex2Dproj(sampler2D s, float4 t);
-
-float4 tex3D(sampler3D s, float3 t);
-float4 tex3D(sampler3D s, float3 t, float3 ddx, float3 ddy);
-float4 tex3Dbias(sampler3D s, float4 t);
-float4 tex3Dgrad(sampler3D s, float3 t, float3 ddx, float3 ddy);
-float4 tex3Dlod(sampler3D s, float4 t);
-float4 tex3Dproj(sampler3D s, float4 t);
-
-float4 texCUBE(samplerCUBE s, float3 t);
-float4 texCUBE(samplerCUBE s, float3 t, float3 ddx, float3 ddy);
-float4 texCUBEbias(samplerCUBE s, float4 t);
-float4 texCUBEgrad(samplerCUBE s, float3 t, float3 ddx, float3 ddy);
-float4 texCUBElod(samplerCUBE s, float4 t);
-float4 texCUBEproj(samplerCUBE s, float4 t);
-*/
-
-// Matrix transpose
-__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,M,N> transpose(matrix<T,N,M> x);
-
-// Truncate to integer
-__generic<T : __BuiltinFloatingPointType> T trunc(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> trunc(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> trunc(matrix<T,N,M> x);
-
-// Shader model 6.0 stuff
-
-uint GlobalOrderedCountIncrement(uint countToAppendForThisLane);
-
-__generic<T : __BuiltinType> T QuadReadLaneAt(T sourceValue, int quadLaneID);
-__generic<T : __BuiltinType, let N : int> vector<T,N> QuadReadLaneAt(vector<T,N> sourceValue, int quadLaneID);
-__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> QuadReadLaneAt(matrix<T,N,M> sourceValue, int quadLaneID);
-
-__generic<T : __BuiltinType> T QuadSwapX(T localValue);
-__generic<T : __BuiltinType, let N : int> vector<T,N> QuadSwapX(vector<T,N> localValue);
-__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> QuadSwapX(matrix<T,N,M> localValue);
-
-__generic<T : __BuiltinType> T QuadSwapY(T localValue);
-__generic<T : __BuiltinType, let N : int> vector<T,N> QuadSwapY(vector<T,N> localValue);
-__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> QuadSwapY(matrix<T,N,M> localValue);
-
-__generic<T : __BuiltinIntegerType> T WaveAllBitAnd(T expr);
-__generic<T : __BuiltinIntegerType, let N : int> vector<T,N> WaveAllBitAnd(vector<T,N> expr);
-__generic<T : __BuiltinIntegerType, let N : int, let M : int> matrix<T,N,M> WaveAllBitAnd(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinIntegerType> T WaveAllBitOr(T expr);
-__generic<T : __BuiltinIntegerType, let N : int> vector<T,N> WaveAllBitOr(vector<T,N> expr);
-__generic<T : __BuiltinIntegerType, let N : int, let M : int> matrix<T,N,M> WaveAllBitOr(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinIntegerType> T WaveAllBitXor(T expr);
-__generic<T : __BuiltinIntegerType, let N : int> vector<T,N> WaveAllBitXor(vector<T,N> expr);
-__generic<T : __BuiltinIntegerType, let N : int, let M : int> matrix<T,N,M> WaveAllBitXor(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinArithmeticType> T WaveAllMax(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllMax(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllMax(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinArithmeticType> T WaveAllMin(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllMin(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllMin(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinArithmeticType> T WaveAllProduct(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllProduct(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllProduct(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinArithmeticType> T WaveAllSum(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllSum(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllSum(matrix<T,N,M> expr);
-
-bool WaveAllEqual(bool expr);
-bool WaveAllTrue(bool expr);
-bool WaveAnyTrue(bool expr);
-
-uint64_t WaveBallot(bool expr);
-
-uint WaveGetLaneCount();
-uint WaveGetLaneIndex();
-uint WaveGetOrderedIndex();
-
-bool WaveIsHelperLane();
-
-bool WaveOnce();
-
-__generic<T : __BuiltinArithmeticType> T WavePrefixProduct(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WavePrefixProduct(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WavePrefixProduct(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinArithmeticType> T WavePrefixSum(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WavePrefixSum(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WavePrefixSum(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinType> T WaveReadFirstLane(T expr);
-__generic<T : __BuiltinType, let N : int> vector<T,N> WaveReadFirstLane(vector<T,N> expr);
-__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> WaveReadFirstLane(matrix<T,N,M> expr);
-
-__generic<T : __BuiltinType> T WaveReadLaneAt(T expr, int laneIndex);
-__generic<T : __BuiltinType, let N : int> vector<T,N> WaveReadLaneAt(vector<T,N> expr, int laneIndex);
-__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> WaveReadLaneAt(matrix<T,N,M> expr, int laneIndex);
-
-// `typedef`s to help with the fact that HLSL has been sorta-kinda case insensitive at various points
-typedef Texture2D texture2D;
-
-${{{{
-// Component-wise multiplication ops
-for(auto op : binaryOps)
-{
-    switch (op.opCode)
-    {
-    default:
-        continue;
-
-    case kIROp_Mul:
-    case kIRPseudoOp_MulAssign:
-        break;
-    }
-
-    for (auto type : kBaseTypes)
-    {
-        if ((type.flags & op.flags) == 0)
-            continue;
-
-        char const* leftType = type.name;
-        char const* rightType = leftType;
-        char const* resultType = leftType;
-
-        char const* leftQual = "";
-        if(op.flags & ASSIGNMENT) leftQual = "in out ";
-
-        sb << "__generic<let N : int, let M : int> ";
-        sb << "__intrinsic_op(" << int(op.opCode) << ") matrix<" << resultType << ",N,M> operator" << op.opName << "(" << leftQual << "matrix<" << leftType << ",N,M> left, matrix<" << rightType << ",N,M> right);\n";
-    }
-}
-
-//
-
-// Buffer types
-
-static const struct {
-    char const*         name;
-    SlangResourceAccess access;
-} kBaseBufferAccessLevels[] = {
-    { "",                   SLANG_RESOURCE_ACCESS_READ },
-    { "RW",                 SLANG_RESOURCE_ACCESS_READ_WRITE },
-    { "RasterizerOrdered",  SLANG_RESOURCE_ACCESS_RASTER_ORDERED },
-};
-static const int kBaseBufferAccessLevelCount = sizeof(kBaseBufferAccessLevels) / sizeof(kBaseBufferAccessLevels[0]);
-
-for (int aa = 0; aa < kBaseBufferAccessLevelCount; ++aa)
-{
-    auto flavor = TextureFlavor::create(TextureFlavor::Shape::ShapeBuffer, kBaseBufferAccessLevels[aa].access).flavor;
-    sb << "__generic<T>\n";
-    sb << "__magic_type(Texture," << int(flavor) << ")\n";
-    sb << "__intrinsic_type(" << (kIROp_TextureType + (int(flavor) << kIROpMeta_OtherShift)) << ")\n";
-    sb << "struct ";
-    sb << kBaseBufferAccessLevels[aa].name;
-    sb << "Buffer {\n";
-
-    sb << "void GetDimensions(out uint dim);\n";
-
-    sb << "__glsl_extension(GL_EXT_samplerless_texture_functions)";
-    sb << "__target_intrinsic(glsl, \"texelFetch($0, $1)$z\")\n";
-    sb << "T Load(int location);\n";
-
-    sb << "T Load(int location, out uint status);\n";
-
-    sb << "__subscript(uint index) -> T {\n";
-
-    sb << "__glsl_extension(GL_EXT_samplerless_texture_functions)";
-    sb << "__target_intrinsic(glsl, \"texelFetch($0, int($1))$z\") get;\n";
-
-    if (kBaseBufferAccessLevels[aa].access != SLANG_RESOURCE_ACCESS_READ)
-    {
-        sb << "ref;\n";
-    }
-
-    sb << "}\n";
-
-    sb << "};\n";
-}
-}}}}
-
-
-// DirectX Raytracing (DXR) Support
-//
-// The following is based on the experimental DXR SDK v0.09.01.
-//
-// Numbering follows the sections in the "D3D12 Raytracing Functional Spec" v0.09 (2018-03-12)
-//
-
-// 10.1.1 - Ray Flags
-
-typedef uint RAY_FLAG;
-
-static const RAY_FLAG RAY_FLAG_NONE                             = 0x00;
-static const RAY_FLAG RAY_FLAG_FORCE_OPAQUE                     = 0x01;
-static const RAY_FLAG RAY_FLAG_FORCE_NON_OPAQUE                 = 0x02;
-static const RAY_FLAG RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH  = 0x04;
-static const RAY_FLAG RAY_FLAG_SKIP_CLOSEST_HIT_SHADER          = 0x08;
-static const RAY_FLAG RAY_FLAG_CULL_BACK_FACING_TRIANGLES       = 0x10;
-static const RAY_FLAG RAY_FLAG_CULL_FRONT_FACING_TRIANGLES      = 0x20;
-static const RAY_FLAG RAY_FLAG_CULL_OPAQUE                      = 0x40;
-static const RAY_FLAG RAY_FLAG_CULL_NON_OPAQUE                  = 0x80;
-
-// 10.1.2 - Ray Description Structure
-
-__builtin
-__magic_type(RayDescType)
-__intrinsic_type($(kIROp_RayDescType))
-struct RayDesc
-{
-    __target_intrinsic(hlsl, Origin)
-    float3 Origin;
-
-    __target_intrinsic(hlsl, TMin)
-    float  TMin;
-
-    __target_intrinsic(hlsl, Direction)
-    float3 Direction;
-
-    __target_intrinsic(hlsl, TMax)
-    float  TMax;
-};
-
-// 10.1.3 - Ray Acceleration Structure
-
-__builtin
-__magic_type(RaytracingAccelerationStructureType)
-__intrinsic_type($(kIROp_RaytracingAccelerationStructureType))
-struct RaytracingAccelerationStructure {};
-
-// 10.1.4 - Subobject Definitions
-
-// TODO: We may decide to support these, but their reliance on C++ implicit
-// constructor call syntax (`SomeType someVar(arg0, arg1);`) makes them
-// annoying for the current Slang parsing strategy, and using global variables
-// for this stuff comes across as a kludge rather than the best possible design.
-
-// 10.1.5 - Intersection Attributes Structure
-
-__builtin
-__magic_type(BuiltInTriangleIntersectionAttributesType)
-__intrinsic_type($(kIROp_BuiltInTriangleIntersectionAttributesType))
-struct BuiltInTriangleIntersectionAttributes
-{
-    __target_intrinsic(hlsl, barycentrics)
-    float2 barycentrics;
-};
-
-// 10.2 Shaders
-
-// Right now new shader stages need to be added directly to the compiler
-// implementation, rather than being something that can be declared in the stdlib.
-
-// 10.3 - Intrinsics
-
-// 10.3.1
-void CallShader<param_t>(uint ShaderIndex, inout param_t Parameter);
-
-// 10.3.2
-void TraceRay<payload_t>(
-    RaytracingAccelerationStructure AccelerationStructure,
-    uint                            RayFlags,
-    uint                            InstanceInclusionMask,
-    uint                            RayContributionToHitGroupIndex,
-    uint                            MultiplierForGeometryContributionToHitGroupIndex,
-    uint                            MissShaderIndex,
-    RayDesc                         Ray,
-    inout payload_t                 Payload);
-
-// 10.3.3
-bool ReportHit<attr_t>(float THit, uint HitKind, attr_t Attributes);
-
-// 10.3.4
-void IgnoreHit();
-
-// 10.3.5
-void AcceptHitAndEndSearch();
-
-// 10.4 - System Values and Special Semantics
-
-// TODO: Many of these functions need to be restricted so that
-// they can only be accessed from specific stages.
-
-// 10.4.1 - Ray Dispatch System Values
-uint2 DispatchRaysIndex();
-uint2 DispatchRaysDimensions();
-
-// 10.4.2 - Ray System Values
-float3 WorldRayOrigin();
-float3 WorldRayDirection();
-float RayTMin();
-float RayTCurrent();
-uint RayFlags();
-
-// 10.4.3 - Primitive/Object Space System Values
-uint InstanceIndex();
-uint InstanceID();
-uint PrimitiveIndex();
-float3 ObjectRayOrigin();
-float3 ObjectRayDirection();
-float3x4 ObjectToWorld();
-float3x4 WorldToObject();
-
-// 10.4.4 - Hit Specific System values
-uint HitKind();
+// Slang HLSL compatibility library

+

+typedef uint UINT;

+

+__generic<T>

+__magic_type(HLSLAppendStructuredBufferType)

+__intrinsic_type($(kIROp_HLSLAppendStructuredBufferType))

+struct AppendStructuredBuffer

+{

+    void Append(T value);

+

+    void GetDimensions(

+        out uint numStructs,

+        out uint stride);

+};

+

+__magic_type(HLSLByteAddressBufferType)

+__intrinsic_type($(kIROp_HLSLByteAddressBufferType))

+struct ByteAddressBuffer

+{

+    void GetDimensions(

+        out uint dim);

+

+    uint Load(int location);

+    uint Load(int location, out uint status);

+

+    uint2 Load2(int location);

+    uint2 Load2(int location, out uint status);

+

+    uint3 Load3(int location);

+    uint3 Load3(int location, out uint status);

+

+    uint4 Load4(int location);

+    uint4 Load4(int location, out uint status);

+};

+

+__generic<T>

+__magic_type(HLSLStructuredBufferType)

+__intrinsic_type($(kIROp_HLSLStructuredBufferType))

+struct StructuredBuffer

+{

+    void GetDimensions(

+        out uint numStructs,

+        out uint stride);

+

+    T Load(int location);

+    T Load(int location, out uint status);

+

+    __subscript(uint index) -> T { __intrinsic_op(bufferLoad) get; };

+};

+

+__generic<T>

+__magic_type(HLSLConsumeStructuredBufferType)

+__intrinsic_type($(kIROp_HLSLConsumeStructuredBufferType))

+struct ConsumeStructuredBuffer

+{

+    T Consume();

+

+    void GetDimensions(

+        out uint numStructs,

+        out uint stride);

+};

+

+__generic<T, let N : int>

+__magic_type(HLSLInputPatchType)

+__intrinsic_type($(kIROp_HLSLInputPatchType))

+struct InputPatch

+{

+    __subscript(uint index) -> T;

+};

+

+__generic<T, let N : int>

+__magic_type(HLSLOutputPatchType)

+__intrinsic_type($(kIROp_HLSLOutputPatchType))

+struct OutputPatch

+{

+    __subscript(uint index) -> T;

+};

+

+${{{{

+static const struct {

+    IROp op;

+    char const* name;

+} kMutableByteAddressBufferCases[] =

+{

+    { kIROp_HLSLRWByteAddressBufferType,                "RWByteAddressBuffer" },

+    { kIROp_HLSLRasterizerOrderedByteAddressBufferType, "RasterizerOrderedByteAddressBuffer" },

+};

+for(auto item : kMutableByteAddressBufferCases) {

+}}}}

+

+__magic_type(HLSL$(item.name)Type)

+__intrinsic_type($(item.op))

+struct $(item.name)

+{

+    // Note(tfoley): supports alll operations from `ByteAddressBuffer`

+    // TODO(tfoley): can this be made a sub-type?

+

+    void GetDimensions(

+        out uint dim);

+

+    uint Load(int location);

+    uint Load(int location, out uint status);

+

+    uint2 Load2(int location);

+    uint2 Load2(int location, out uint status);

+

+    uint3 Load3(int location);

+    uint3 Load3(int location, out uint status);

+

+    uint4 Load4(int location);

+    uint4 Load4(int location, out uint status);

+

+    // Added operations:

+

+    void InterlockedAdd(

+        UINT dest,

+        UINT value,

+        out UINT original_value);

+    void InterlockedAdd(

+        UINT dest,

+        UINT value);

+

+    void InterlockedAnd(

+        UINT dest,

+        UINT value,

+        out UINT original_value);

+    void InterlockedAnd(

+        UINT dest,

+        UINT value);

+

+    void InterlockedCompareExchange(

+        UINT dest,

+        UINT compare_value,

+        UINT value,

+        out UINT original_value);

+    void InterlockedCompareExchange(

+        UINT dest,

+        UINT compare_value,

+        UINT value);

+

+    void InterlockedCompareStore(

+        UINT dest,

+        UINT compare_value,

+        UINT value);

+    void InterlockedCompareStore(

+        UINT dest,

+        UINT compare_value);

+

+    void InterlockedExchange(

+        UINT dest,

+        UINT value,

+        out UINT original_value);

+    void InterlockedExchange(

+        UINT dest,

+        UINT value);

+

+    void InterlockedMax(

+        UINT dest,

+        UINT value,

+        out UINT original_value);

+    void InterlockedMax(

+        UINT dest,

+        UINT value);

+

+    void InterlockedMin(

+        UINT dest,

+        UINT value,

+        out UINT original_value);

+    void InterlockedMin(

+        UINT dest,

+        UINT value);

+

+    void InterlockedOr(

+        UINT dest,

+        UINT value,

+        out UINT original_value);

+    void InterlockedOr(

+        UINT dest,

+        UINT value);

+

+    void InterlockedXor(

+        UINT dest,

+        UINT value,

+        out UINT original_value);

+    void InterlockedXor(

+        UINT dest,

+        UINT value);

+

+    void Store(

+        uint address,

+        uint value);

+

+    void Store2(

+        uint address,

+        uint2 value);

+

+    void Store3(

+        uint address,

+        uint3 value);

+

+    void Store4(

+        uint address,

+        uint4 value);

+};

+

+${{{{

+}

+}}}}

+

+${{{{

+static const struct {

+    IROp op;

+    char const* name;

+} kMutableStructuredBufferCases[] =

+{

+    { kIROp_HLSLRWStructuredBufferType,                "RWStructuredBuffer" },

+    { kIROp_HLSLRasterizerOrderedStructuredBufferType, "RasterizerOrderedStructuredBuffer" },

+};

+for(auto item : kMutableStructuredBufferCases) {

+}}}}

+

+

+__generic<T>

+__magic_type(HLSL$(item.name)Type)

+__intrinsic_type($(item.op))

+struct $(item.name)

+{

+    uint DecrementCounter();

+

+    void GetDimensions(

+        out uint numStructs,

+        out uint stride);

+

+    uint IncrementCounter();

+

+    T Load(int location);

+    T Load(int location, out uint status);

+

+	__subscript(uint index) -> T

+	{

+        __intrinsic_op(bufferElementRef)

+        ref;

+	}

+};

+

+${{{{

+}

+}}}}

+

+__generic<T>

+__magic_type(HLSLPointStreamType)

+__intrinsic_type($(kIROp_HLSLPointStreamType))

+struct PointStream

+{

+    __target_intrinsic(glsl, "EmitVertex()")

+    void Append(T value);

+

+    __target_intrinsic(glsl, "EndPrimitive()")

+    void RestartStrip();

+};

+

+__generic<T>

+__magic_type(HLSLLineStreamType)

+__intrinsic_type($(kIROp_HLSLLineStreamType))

+struct LineStream

+{

+    __target_intrinsic(glsl, "EmitVertex()")

+    void Append(T value);

+

+    __target_intrinsic(glsl, "EndPrimitive()")

+    void RestartStrip();

+};

+

+__generic<T>

+__magic_type(HLSLTriangleStreamType)

+__intrinsic_type($(kIROp_HLSLTriangleStreamType))

+struct TriangleStream

+{

+    __target_intrinsic(glsl, "EmitVertex()")

+    void Append(T value);

+

+    __target_intrinsic(glsl, "EndPrimitive()")

+    void RestartStrip();

+};

+

+// Note(tfoley): Trying to systematically add all the HLSL builtins

+

+// Try to terminate the current draw or dispatch call (HLSL SM 4.0)

+void abort();

+

+// Absolute value (HLSL SM 1.0)

+__generic<T : __BuiltinSignedArithmeticType> T abs(T x);

+__generic<T : __BuiltinSignedArithmeticType, let N : int> vector<T,N> abs(vector<T,N> x);

+__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> matrix<T,N,M> abs(matrix<T,N,M> x);

+

+// Inverse cosine (HLSL SM 1.0)

+__generic<T : __BuiltinFloatingPointType> T acos(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> acos(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> acos(matrix<T,N,M> x);

+

+// Test if all components are non-zero (HLSL SM 1.0)

+__generic<T : __BuiltinType> bool all(T x);

+__generic<T : __BuiltinType, let N : int> bool all(vector<T,N> x);

+__generic<T : __BuiltinType, let N : int, let M : int> bool all(matrix<T,N,M> x);

+

+// Barrier for writes to all memory spaces (HLSL SM 5.0)

+void AllMemoryBarrier();

+

+// Thread-group sync and barrier for writes to all memory spaces (HLSL SM 5.0)

+void AllMemoryBarrierWithGroupSync();

+

+// Test if any components is non-zero (HLSL SM 1.0)

+

+__generic<T : __BuiltinType>

+__target_intrinsic(glsl, "bool($0)")

+bool any(T x);

+

+__generic<T : __BuiltinType, let N : int>

+__target_intrinsic(glsl, "any(bvec$N0($0))")

+bool any(vector<T,N> x);

+

+__generic<T : __BuiltinType, let N : int, let M : int>

+// TODO: need to define GLSL mapping

+bool any(matrix<T,N,M> x);

+

+

+// Reinterpret bits as a double (HLSL SM 5.0)

+double asdouble(uint lowbits, uint highbits);

+

+// Reinterpret bits as a float (HLSL SM 4.0)

+float asfloat( int x);

+float asfloat(uint x);

+__generic<let N : int> vector<float,N> asfloat(vector< int,N> x);

+__generic<let N : int> vector<float,N> asfloat(vector<uint,N> x);

+__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix< int,N,M> x);

+__generic<let N : int, let M : int> matrix<float,N,M> asfloat(matrix<uint,N,M> x);

+

+

+// Inverse sine (HLSL SM 1.0)

+__generic<T : __BuiltinFloatingPointType> T asin(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> asin(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> asin(matrix<T,N,M> x);

+

+// Reinterpret bits as an int (HLSL SM 4.0)

+int asint(float x);

+int asint(uint x);

+__generic<let N : int> vector<int,N> asint(vector<float,N> x);

+__generic<let N : int> vector<int,N> asint(vector<uint,N> x);

+__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<float,N,M> x);

+__generic<let N : int, let M : int> matrix<int,N,M> asint(matrix<uint,N,M> x);

+

+// Reinterpret bits of double as a uint (HLSL SM 5.0)

+void asuint(double value, out uint lowbits, out uint highbits);

+

+// Reinterpret bits as a uint (HLSL SM 4.0)

+uint asuint(float x);

+uint asuint(int x);

+__generic<let N : int> vector<uint,N> asuint(vector<float,N> x);

+__generic<let N : int> vector<uint,N> asuint(vector<int,N> x);

+__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<float,N,M> x);

+__generic<let N : int, let M : int> matrix<uint,N,M> asuint(matrix<int,N,M> x);

+

+// Inverse tangent (HLSL SM 1.0)

+__generic<T : __BuiltinFloatingPointType> T atan(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> atan(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> atan(matrix<T,N,M> x);

+

+__generic<T : __BuiltinFloatingPointType>

+__target_intrinsic(glsl,"atan($0,$1)")

+T atan2(T y, T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__target_intrinsic(glsl,"atan($0,$1)")

+vector<T,N> atan2(vector<T,N> y, vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__target_intrinsic(glsl,"atan($0,$1)")

+matrix<T,N,M> atan2(matrix<T,N,M> y, matrix<T,N,M> x);

+

+// Ceiling (HLSL SM 1.0)

+__generic<T : __BuiltinFloatingPointType> T ceil(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> ceil(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> ceil(matrix<T,N,M> x);

+

+

+// Check access status to tiled resource

+bool CheckAccessFullyMapped(uint status);

+

+// Clamp (HLSL SM 1.0)

+__generic<T : __BuiltinArithmeticType> T clamp(T x, T min, T max);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> clamp(vector<T,N> x, vector<T,N> min, vector<T,N> max);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> clamp(matrix<T,N,M> x, matrix<T,N,M> min, matrix<T,N,M> max);

+

+// Clip (discard) fragment conditionally

+__generic<T : __BuiltinFloatingPointType> void clip(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> void clip(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> void clip(matrix<T,N,M> x);

+

+// Cosine

+__generic<T : __BuiltinFloatingPointType> T cos(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> cos(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> cos(matrix<T,N,M> x);

+

+// Hyperbolic cosine

+__generic<T : __BuiltinFloatingPointType> T cosh(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> cosh(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> cosh(matrix<T,N,M> x);

+

+// Population count

+__target_intrinsic(glsl, "bitCount")

+uint countbits(uint value);

+

+// Cross product

+__generic<T : __BuiltinArithmeticType> vector<T,3> cross(vector<T,3> x, vector<T,3> y);

+

+// Convert encoded color

+int4 D3DCOLORtoUBYTE4(float4 x);

+

+// Partial-difference derivatives

+__generic<T : __BuiltinFloatingPointType>

+__target_intrinsic(glsl, dFdx)

+T ddx(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__target_intrinsic(glsl, dFdx)

+vector<T,N> ddx(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__target_intrinsic(glsl, dFdx)

+matrix<T,N,M> ddx(matrix<T,N,M> x);

+

+__generic<T : __BuiltinFloatingPointType>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdxCoarse)

+T ddx_coarse(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdxCoarse)

+vector<T,N> ddx_coarse(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdxCoarse)

+matrix<T,N,M> ddx_coarse(matrix<T,N,M> x);

+

+__generic<T : __BuiltinFloatingPointType>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdxFine)

+T ddx_fine(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdxFine)

+vector<T,N> ddx_fine(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdxFine)

+matrix<T,N,M> ddx_fine(matrix<T,N,M> x);

+

+__generic<T : __BuiltinFloatingPointType>

+__target_intrinsic(glsl, dFdy)

+T ddy(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__target_intrinsic(glsl, dFdy)

+vector<T,N> ddy(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__target_intrinsic(glsl, dFdy)

+ matrix<T,N,M> ddy(matrix<T,N,M> x);

+

+__generic<T : __BuiltinFloatingPointType>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdyCoarse)

+T ddy_coarse(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdyCoarse)

+vector<T,N> ddy_coarse(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdyCoarse)

+matrix<T,N,M> ddy_coarse(matrix<T,N,M> x);

+

+__generic<T : __BuiltinFloatingPointType>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdyFine)

+T ddy_fine(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdyFine)

+vector<T,N> ddy_fine(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__glsl_extension(GL_ARB_derivative_control)

+__target_intrinsic(glsl, dFdyFine)

+matrix<T,N,M> ddy_fine(matrix<T,N,M> x);

+

+

+// Radians to degrees

+__generic<T : __BuiltinFloatingPointType> T degrees(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> degrees(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> degrees(matrix<T,N,M> x);

+

+// Matrix determinant

+

+__generic<T : __BuiltinFloatingPointType, let N : int> T determinant(matrix<T,N,N> m);

+

+// Barrier for device memory

+void DeviceMemoryBarrier();

+void DeviceMemoryBarrierWithGroupSync();

+

+// Vector distance

+

+__generic<T : __BuiltinFloatingPointType, let N : int> T distance(vector<T,N> x, vector<T,N> y);

+

+// Vector dot product

+

+__generic<T : __BuiltinArithmeticType, let N : int> T dot(vector<T,N> x, vector<T,N> y);

+

+// Helper for computing distance terms for lighting (obsolete)

+

+__generic<T : __BuiltinFloatingPointType> vector<T,4> dst(vector<T,4> x, vector<T,4> y);

+

+// Error message

+

+// void errorf( string format, ... );

+

+// Attribute evaluation

+

+__generic<T : __BuiltinArithmeticType> T EvaluateAttributeAtCentroid(T x);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> EvaluateAttributeAtCentroid(vector<T,N> x);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> EvaluateAttributeAtCentroid(matrix<T,N,M> x);

+

+__generic<T : __BuiltinArithmeticType> T EvaluateAttributeAtSample(T x, uint sampleindex);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> EvaluateAttributeAtSample(vector<T,N> x, uint sampleindex);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> EvaluateAttributeAtSample(matrix<T,N,M> x, uint sampleindex);

+

+__generic<T : __BuiltinArithmeticType> T EvaluateAttributeSnapped(T x, int2 offset);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> EvaluateAttributeSnapped(vector<T,N> x, int2 offset);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> EvaluateAttributeSnapped(matrix<T,N,M> x, int2 offset);

+

+// Base-e exponent

+__generic<T : __BuiltinFloatingPointType> T exp(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> exp(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> exp(matrix<T,N,M> x);

+

+// Base-2 exponent

+__generic<T : __BuiltinFloatingPointType> T exp2(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> exp2(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> exp2(matrix<T,N,M> x);

+

+// Convert 16-bit float stored in low bits of integer

+float f16tof32(uint value);

+__generic<let N : int> vector<float,N> f16tof32(vector<uint,N> value);

+

+// Convert to 16-bit float stored in low bits of integer

+uint f32tof16(float value);

+__generic<let N : int> vector<uint,N> f32tof16(vector<float,N> value);

+

+// Flip surface normal to face forward, if needed

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> faceforward(vector<T,N> n, vector<T,N> i, vector<T,N> ng);

+

+// Find first set bit starting at high bit and working down

+__target_intrinsic(glsl,"findMSB")

+int firstbithigh(int value);

+

+__target_intrinsic(glsl,"findMSB")

+__generic<let N : int> vector<int,N> firstbithigh(vector<int,N> value);

+

+__target_intrinsic(glsl,"findMSB")

+uint firstbithigh(uint value);

+

+__target_intrinsic(glsl,"findMSB")

+__generic<let N : int> vector<uint,N> firstbithigh(vector<uint,N> value);

+

+// Find first set bit starting at low bit and working up

+__target_intrinsic(glsl,"findLSB")

+int firstbitlow(int value);

+

+__target_intrinsic(glsl,"findLSB")

+__generic<let N : int> vector<int,N> firstbitlow(vector<int,N> value);

+

+__target_intrinsic(glsl,"findLSB")

+uint firstbitlow(uint value);

+

+__target_intrinsic(glsl,"findLSB")

+__generic<let N : int> vector<uint,N> firstbitlow(vector<uint,N> value);

+

+// Floor (HLSL SM 1.0)

+__generic<T : __BuiltinFloatingPointType> T floor(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> floor(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> floor(matrix<T,N,M> x);

+

+// Fused multiply-add for doubles

+double fma(double a, double b, double c);

+__generic<let N : int> vector<double, N> fma(vector<double, N> a, vector<double, N> b, vector<double, N> c);

+__generic<let N : int, let M : int> matrix<double,N,M> fma(matrix<double,N,M> a, matrix<double,N,M> b, matrix<double,N,M> c);

+

+// Floating point remainder of x/y

+__generic<T : __BuiltinFloatingPointType> T fmod(T x, T y);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> fmod(vector<T,N> x, vector<T,N> y);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> fmod(matrix<T,N,M> x, matrix<T,N,M> y);

+

+// Fractional part

+__generic<T : __BuiltinFloatingPointType>

+__target_intrinsic(glsl, fract)

+T frac(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__target_intrinsic(glsl, fract)

+vector<T,N> frac(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__target_intrinsic(glsl, fract)

+matrix<T,N,M> frac(matrix<T,N,M> x);

+

+// Split float into mantissa and exponent

+__generic<T : __BuiltinFloatingPointType> T frexp(T x, out T exp);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> frexp(vector<T,N> x, out vector<T,N> exp);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> frexp(matrix<T,N,M> x, out matrix<T,N,M> exp);

+

+// Texture filter width

+__generic<T : __BuiltinFloatingPointType> T fwidth(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> fwidth(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> fwidth(matrix<T,N,M> x);

+

+// Get number of samples in render target

+uint GetRenderTargetSampleCount();

+

+// Get position of given sample

+float2 GetRenderTargetSamplePosition(int Index);

+

+// Group memory barrier

+__target_intrinsic(glsl, "groupMemoryBarrier")

+void GroupMemoryBarrier();

+

+// Note: the unmatched parentheses in the GLSL lowering are

+// to cancel out the parens that the emit logic uses, so that

+// we can emit this as if it were an expression.

+//

+// TODO: investigate whether we can just use "operator comma" here.

+__target_intrinsic(glsl, "groupMemoryBarrier()); (barrier()")

+void GroupMemoryBarrierWithGroupSync();

+

+// Atomics

+

+__target_intrinsic(glsl, "$atomicAdd($A, $1)")

+void InterlockedAdd(__ref  int dest,  int value);

+

+__target_intrinsic(glsl, "$atomicAdd($A, $1)")

+void InterlockedAdd(__ref uint dest, uint value);

+

+__target_intrinsic(glsl, "($2 = $atomicAdd($A, $1))")

+void InterlockedAdd(__ref  int dest,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($2 = $atomicAdd($A, $1))")

+void InterlockedAdd(__ref uint dest, uint value, out uint original_value);

+

+__target_intrinsic(glsl, "$atomicAnd($A, $1)")

+void InterlockedAnd(__ref  int dest,  int value);

+

+__target_intrinsic(glsl, "$atomicAnd($A, $1)")

+void InterlockedAnd(__ref uint dest, uint value);

+

+__target_intrinsic(glsl, "($2 = $atomicAnd($A, $1))")

+void InterlockedAnd(__ref  int dest,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($2 = $atomicAnd($A, $1))")

+void InterlockedAnd(__ref uint dest, uint value, out uint original_value);

+

+__target_intrinsic(glsl, "($3 = $atomicCompSwap($A, $1, $2))")

+void InterlockedCompareExchange(__ref  int dest,  int compare_value,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($3 = $atomicCompSwap($A, $1, $2))")

+void InterlockedCompareExchange(__ref uint dest, uint compare_value, uint value, out uint original_value);

+

+__target_intrinsic(glsl, "$atomicCompSwap($A, $1, $2)")

+void InterlockedCompareStore(__ref  int dest,  int compare_value,  int value);

+

+__target_intrinsic(glsl, "$atomicCompSwap($A, $1, $2)")

+void InterlockedCompareStore(__ref uint dest, uint compare_value, uint value);

+

+__target_intrinsic(glsl, "$atomicExchange($A, $1)")

+void InterlockedExchange(__ref  int dest,  int value);

+

+__target_intrinsic(glsl, "$atomicExchange($A, $1)")

+void InterlockedExchange(__ref uint dest, uint value);

+

+__target_intrinsic(glsl, "($2 = $atomicExchange($A, $1))")

+void InterlockedExchange(__ref  int dest,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($2 = $atomicExchange($A, $1))")

+void InterlockedExchange(__ref uint dest, uint value, out uint original_value);

+

+__target_intrinsic(glsl, "$atomicMax($A, $1)")

+void InterlockedMax(__ref  int dest,  int value);

+

+__target_intrinsic(glsl, "$atomicMax($A, $1)")

+void InterlockedMax(__ref uint dest, uint value);

+

+__target_intrinsic(glsl, "($2 = $atomicMax($A, $1))")

+void InterlockedMax(__ref  int dest,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($2 = $atomicMax($A, $1))")

+void InterlockedMax(__ref uint dest, uint value, out uint original_value);

+

+__target_intrinsic(glsl, "$atomicMin($A, $1)")

+void InterlockedMin(in out  int dest,  int value);

+

+__target_intrinsic(glsl, "$atomicMin($A, $1)")

+void InterlockedMin(in out uint dest, uint value);

+

+__target_intrinsic(glsl, "($2 = $atomicMin($A, $1))")

+void InterlockedMin(in out  int dest,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($2 = $atomicMin($A, $1))")

+void InterlockedMin(in out uint dest, uint value, out uint original_value);

+

+__target_intrinsic(glsl, "$atomicOr($A, $1)")

+void InterlockedOr(__ref  int dest,  int value);

+

+__target_intrinsic(glsl, "$atomicOr($A, $1)")

+void InterlockedOr(__ref uint dest, uint value);

+

+__target_intrinsic(glsl, "($2 = $atomicOr($A, $1))")

+void InterlockedOr(__ref  int dest,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($2 = $atomicOr($A, $1))")

+void InterlockedOr(__ref uint dest, uint value, out uint original_value);

+

+__target_intrinsic(glsl, "$atomicXor($A, $1)")

+void InterlockedXor(__ref  int dest,  int value);

+

+__target_intrinsic(glsl, "$atomicXor($A, $1)")

+void InterlockedXor(__ref uint dest, uint value);

+

+__target_intrinsic(glsl, "($2 = $atomicXor($A, $1))")

+void InterlockedXor(__ref  int dest,  int value, out  int original_value);

+

+__target_intrinsic(glsl, "($2 = $atomicXor($A, $1))")

+void InterlockedXor(__ref uint dest, uint value, out uint original_value);

+

+// Is floating-point value finite?

+__generic<T : __BuiltinFloatingPointType> bool isfinite(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<bool,N> isfinite(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<bool,N,M> isfinite(matrix<T,N,M> x);

+

+// Is floating-point value infinite?

+__generic<T : __BuiltinFloatingPointType> bool isinf(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<bool,N> isinf(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<bool,N,M> isinf(matrix<T,N,M> x);

+

+// Is floating-point value not-a-number?

+__generic<T : __BuiltinFloatingPointType> bool isnan(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<bool,N> isnan(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<bool,N,M> isnan(matrix<T,N,M> x);

+

+// Construct float from mantissa and exponent

+__generic<T : __BuiltinFloatingPointType> T ldexp(T x, T exp);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> ldexp(vector<T,N> x, vector<T,N> exp);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> ldexp(matrix<T,N,M> x, matrix<T,N,M> exp);

+

+// Vector length

+__generic<T : __BuiltinFloatingPointType, let N : int> T length(vector<T,N> x);

+

+// Linear interpolation

+__generic<T : __BuiltinFloatingPointType>

+__target_intrinsic(glsl, mix)

+T lerp(T x, T y, T s);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__target_intrinsic(glsl, mix)

+vector<T,N> lerp(vector<T,N> x, vector<T,N> y, vector<T,N> s);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__target_intrinsic(glsl, mix)

+matrix<T,N,M> lerp(matrix<T,N,M> x, matrix<T,N,M> y, matrix<T,N,M> s);

+

+// Legacy lighting function (obsolete)

+float4 lit(float n_dot_l, float n_dot_h, float m);

+

+// Base-e logarithm

+__generic<T : __BuiltinFloatingPointType> T log(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> log(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> log(matrix<T,N,M> x);

+

+// Base-10 logarithm

+__generic<T : __BuiltinFloatingPointType> T log10(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> log10(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> log10(matrix<T,N,M> x);

+

+// Base-2 logarithm

+__generic<T : __BuiltinFloatingPointType> T log2(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> log2(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> log2(matrix<T,N,M> x);

+

+// multiply-add

+__generic<T : __BuiltinArithmeticType> T mad(T mvalue, T avalue, T bvalue);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> mad(vector<T,N> mvalue, vector<T,N> avalue, vector<T,N> bvalue);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> mad(matrix<T,N,M> mvalue, matrix<T,N,M> avalue, matrix<T,N,M> bvalue);

+

+// maximum

+__generic<T : __BuiltinArithmeticType> T max(T x, T y);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> max(vector<T,N> x, vector<T,N> y);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> max(matrix<T,N,M> x, matrix<T,N,M> y);

+

+// minimum

+__generic<T : __BuiltinArithmeticType> T min(T x, T y);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> min(vector<T,N> x, vector<T,N> y);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> min(matrix<T,N,M> x, matrix<T,N,M> y);

+

+// split into integer and fractional parts (both with same sign)

+__generic<T : __BuiltinFloatingPointType> T modf(T x, out T ip);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> modf(vector<T,N> x, out vector<T,N> ip);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> modf(matrix<T,N,M> x, out matrix<T,N,M> ip);

+

+// msad4 (whatever that is)

+uint4 msad4(uint reference, uint2 source, uint4 accum);

+

+// General inner products

+

+// scalar-scalar

+__generic<T : __BuiltinArithmeticType> T mul(T x, T y);

+

+// scalar-vector and vector-scalar

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> mul(vector<T,N> x, T y);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> mul(T x, vector<T,N> y);

+

+// scalar-matrix and matrix-scalar

+__generic<T : __BuiltinArithmeticType, let N : int, let M :int> matrix<T,N,M> mul(matrix<T,N,M> x, T y);

+__generic<T : __BuiltinArithmeticType, let N : int, let M :int> matrix<T,N,M> mul(T x, matrix<T,N,M> y);

+

+// vector-vector (dot product)

+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(dot) T mul(vector<T,N> x, vector<T,N> y);

+

+// vector-matrix

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulVectorMatrix) vector<T,M> mul(vector<T,N> x, matrix<T,N,M> y);

+

+// matrix-vector

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulMatrixVector) vector<T,N> mul(matrix<T,N,M> x, vector<T,M> y);

+

+// matrix-matrix

+__generic<T : __BuiltinArithmeticType, let R : int, let N : int, let C : int> __intrinsic_op(mulMatrixMatrix) matrix<T,R,C> mul(matrix<T,R,N> x, matrix<T,N,C> y);

+

+// noise (deprecated)

+float noise(float x);

+__generic<let N : int> float noise(vector<float, N> x);

+

+/// Indicate that an index may be non-uniform at execution time.

+///

+/// Shader Model 5.1 and 6.x introduce support for dynamic indexing

+/// of arrays of resources, but place the restriction that *by default*

+/// the implementation can assume that any value used as an index into

+/// such arrays will be dynamically uniform across an entire `Draw` or `Dispatch`

+/// (when using instancing, the value must be uniform across all instances;

+/// it does not seem that the restriction extends to draws within a multi-draw).

+///

+/// In order to indicate to the implementation that it cannot make the

+/// uniformity assumption, a shader programmer is required to pass the index

+/// to the `NonUniformResourceIndex` function before using it as an index.

+/// The function superficially acts like an identity function.

+///

+/// Note: a future version of Slang may take responsibility for inserting calls

+/// to this function as necessary in output code, rather than make this

+/// the user's responsibility, so that the default behavior of the language

+/// is more semantically "correct."

+uint NonUniformResourceIndex(uint index);

+int NonUniformResourceIndex(int index);

+

+// Normalize a vector

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> normalize(vector<T,N> x);

+

+// Raise to a power

+__generic<T : __BuiltinFloatingPointType> T pow(T x, T y);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> pow(vector<T,N> x, vector<T,N> y);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> pow(matrix<T,N,M> x, matrix<T,N,M> y);

+

+// Output message

+

+// void printf( string format, ... );

+

+// Tessellation factor fixup routines

+

+void Process2DQuadTessFactorsAvg(

+    in  float4 RawEdgeFactors,

+    in  float2 InsideScale,

+    out float4 RoundedEdgeTessFactors,

+    out float2 RoundedInsideTessFactors,

+    out float2 UnroundedInsideTessFactors);

+

+void Process2DQuadTessFactorsMax(

+    in  float4 RawEdgeFactors,

+    in  float2 InsideScale,

+    out float4 RoundedEdgeTessFactors,

+    out float2 RoundedInsideTessFactors,

+    out float2 UnroundedInsideTessFactors);

+

+void Process2DQuadTessFactorsMin(

+    in  float4 RawEdgeFactors,

+    in  float2 InsideScale,

+    out float4 RoundedEdgeTessFactors,

+    out float2 RoundedInsideTessFactors,

+    out float2 UnroundedInsideTessFactors);

+

+void ProcessIsolineTessFactors(

+    in  float RawDetailFactor,

+    in  float RawDensityFactor,

+    out float RoundedDetailFactor,

+    out float RoundedDensityFactor);

+

+void ProcessQuadTessFactorsAvg(

+    in  float4 RawEdgeFactors,

+    in  float InsideScale,

+    out float4 RoundedEdgeTessFactors,

+    out float2 RoundedInsideTessFactors,

+    out float2 UnroundedInsideTessFactors);

+

+void ProcessQuadTessFactorsMax(

+    in  float4 RawEdgeFactors,

+    in  float InsideScale,

+    out float4 RoundedEdgeTessFactors,

+    out float2 RoundedInsideTessFactors,

+    out float2 UnroundedInsideTessFactors);

+

+void ProcessQuadTessFactorsMin(

+    in  float4 RawEdgeFactors,

+    in  float InsideScale,

+    out float4 RoundedEdgeTessFactors,

+    out float2 RoundedInsideTessFactors,

+    out float2 UnroundedInsideTessFactors);

+

+void ProcessTriTessFactorsAvg(

+    in  float3 RawEdgeFactors,

+    in  float InsideScale,

+    out float3 RoundedEdgeTessFactors,

+    out float RoundedInsideTessFactor,

+    out float UnroundedInsideTessFactor);

+

+void ProcessTriTessFactorsMax(

+    in  float3 RawEdgeFactors,

+    in  float InsideScale,

+    out float3 RoundedEdgeTessFactors,

+    out float RoundedInsideTessFactor,

+    out float UnroundedInsideTessFactor);

+

+void ProcessTriTessFactorsMin(

+    in  float3 RawEdgeFactors,

+    in  float InsideScale,

+    out float3 RoundedEdgeTessFactors,

+    out float RoundedInsideTessFactors,

+    out float UnroundedInsideTessFactors);

+

+// Degrees to radians

+__generic<T : __BuiltinFloatingPointType> T radians(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> radians(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> radians(matrix<T,N,M> x);

+

+// Approximate reciprocal

+__generic<T : __BuiltinFloatingPointType> T rcp(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> rcp(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> rcp(matrix<T,N,M> x);

+

+// Reflect incident vector across plane with given normal

+__generic<T : __BuiltinFloatingPointType, let N : int>

+vector<T,N> reflect(vector<T,N> i, vector<T,N> n);

+

+// Refract incident vector given surface normal and index of refraction

+__generic<T : __BuiltinFloatingPointType, let N : int>

+vector<T,N> refract(vector<T,N> i, vector<T,N> n, float eta);

+

+// Reverse order of bits

+__target_intrinsic(glsl, "bitfieldReverse")

+uint reversebits(uint value);

+

+__target_intrinsic(glsl, "bitfieldReverse")

+__generic<let N : int> vector<uint,N> reversebits(vector<uint,N> value);

+

+// Round-to-nearest

+__generic<T : __BuiltinFloatingPointType> T round(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> round(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> round(matrix<T,N,M> x);

+

+// Reciprocal of square root

+__generic<T : __BuiltinFloatingPointType> T rsqrt(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> rsqrt(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> rsqrt(matrix<T,N,M> x);

+

+// Clamp value to [0,1] range

+__generic<T : __BuiltinFloatingPointType>

+__target_intrinsic(glsl, "clamp($0, 0, 1)")

+T saturate(T x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__target_intrinsic(glsl, "clamp($0, 0, 1)")

+vector<T,N> saturate(vector<T,N> x);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__target_intrinsic(glsl, "clamp($0, 0, 1)")

+matrix<T,N,M> saturate(matrix<T,N,M> x);

+

+__generic<T : __BuiltinFloatingPointType>

+__specialized_for_target(glsl)

+T saturate(T x)

+{

+    return clamp<T>(x, T(0), T(1));

+}

+

+__generic<T : __BuiltinFloatingPointType, let N : int>

+__specialized_for_target(glsl)

+vector<T,N> saturate(vector<T,N> x)

+{

+    return clamp<T,N>(x,

+        vector<T,N>(T(0)),

+        vector<T,N>(T(1)));

+}

+

+// HACK: need a helper to turn a scalar into a matrix,

+// because GLSL and HLSL disagree on the semantics of

+// constructing a matrix from a single scalar.

+__generic<T, let N : int, let M : int>

+matrix<T,N,M> __scalarToMatrix(T value);

+

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>

+__specialized_for_target(glsl)

+matrix<T,N,M> saturate(matrix<T,N,M> x)

+{

+    return clamp<T,N,M>(x,

+        __scalarToMatrix<T,N,M>(T(0)),

+        __scalarToMatrix<T,N,M>(T(1)));

+}

+

+

+// Extract sign of value

+__generic<T : __BuiltinSignedArithmeticType> int sign(T x);

+__generic<T : __BuiltinSignedArithmeticType, let N : int> vector<int,N> sign(vector<T,N> x);

+__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> matrix<int,N,M> sign(matrix<T,N,M> x);

+

+

+// Sine

+__generic<T : __BuiltinFloatingPointType> T sin(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> sin(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> sin(matrix<T,N,M> x);

+

+// Sine and cosine

+__generic<T : __BuiltinFloatingPointType, let N : int> void sincos(T x, out T s, out T c);

+__generic<T : __BuiltinFloatingPointType, let N : int> void sincos(vector<T,N> x, out vector<T,N> s, out vector<T,N> c);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> void sincos(matrix<T,N,M> x, out matrix<T,N,M> s, out matrix<T,N,M> c);

+

+// Hyperbolic Sine

+__generic<T : __BuiltinFloatingPointType> T sinh(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> sinh(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> sinh(matrix<T,N,M> x);

+

+// Smooth step (Hermite interpolation)

+__generic<T : __BuiltinFloatingPointType> T smoothstep(T min, T max, T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> smoothstep(vector<T,N> min, vector<T,N> max, vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> smoothstep(matrix<T,N,M> min, matrix<T,N,M> max, matrix<T,N,M> x);

+

+// Square root

+__generic<T : __BuiltinFloatingPointType> T sqrt(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> sqrt(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> sqrt(matrix<T,N,M> x);

+

+// Step function

+__generic<T : __BuiltinFloatingPointType> T step(T y, T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> step(vector<T,N> y, vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> step(matrix<T,N,M> y, matrix<T,N,M> x);

+

+// Tangent

+__generic<T : __BuiltinFloatingPointType> T tan(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> tan(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> tan(matrix<T,N,M> x);

+

+// Hyperbolic tangent

+__generic<T : __BuiltinFloatingPointType> T tanh(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> tanh(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> tanh(matrix<T,N,M> x);

+

+// Legacy texture-fetch operations

+

+/*

+float4 tex1D(sampler1D s, float t);

+float4 tex1D(sampler1D s, float t, float ddx, float ddy);

+float4 tex1Dbias(sampler1D s, float4 t);

+float4 tex1Dgrad(sampler1D s, float t, float ddx, float ddy);

+float4 tex1Dlod(sampler1D s, float4 t);

+float4 tex1Dproj(sampler1D s, float4 t);

+

+float4 tex2D(sampler2D s, float2 t);

+float4 tex2D(sampler2D s, float2 t, float2 ddx, float2 ddy);

+float4 tex2Dbias(sampler2D s, float4 t);

+float4 tex2Dgrad(sampler2D s, float2 t, float2 ddx, float2 ddy);

+float4 tex2Dlod(sampler2D s, float4 t);

+float4 tex2Dproj(sampler2D s, float4 t);

+

+float4 tex3D(sampler3D s, float3 t);

+float4 tex3D(sampler3D s, float3 t, float3 ddx, float3 ddy);

+float4 tex3Dbias(sampler3D s, float4 t);

+float4 tex3Dgrad(sampler3D s, float3 t, float3 ddx, float3 ddy);

+float4 tex3Dlod(sampler3D s, float4 t);

+float4 tex3Dproj(sampler3D s, float4 t);

+

+float4 texCUBE(samplerCUBE s, float3 t);

+float4 texCUBE(samplerCUBE s, float3 t, float3 ddx, float3 ddy);

+float4 texCUBEbias(samplerCUBE s, float4 t);

+float4 texCUBEgrad(samplerCUBE s, float3 t, float3 ddx, float3 ddy);

+float4 texCUBElod(samplerCUBE s, float4 t);

+float4 texCUBEproj(samplerCUBE s, float4 t);

+*/

+

+// Matrix transpose

+__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,M,N> transpose(matrix<T,N,M> x);

+

+// Truncate to integer

+__generic<T : __BuiltinFloatingPointType> T trunc(T x);

+__generic<T : __BuiltinFloatingPointType, let N : int> vector<T,N> trunc(vector<T,N> x);

+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> matrix<T,N,M> trunc(matrix<T,N,M> x);

+

+// Shader model 6.0 stuff

+

+uint GlobalOrderedCountIncrement(uint countToAppendForThisLane);

+

+__generic<T : __BuiltinType> T QuadReadLaneAt(T sourceValue, int quadLaneID);

+__generic<T : __BuiltinType, let N : int> vector<T,N> QuadReadLaneAt(vector<T,N> sourceValue, int quadLaneID);

+__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> QuadReadLaneAt(matrix<T,N,M> sourceValue, int quadLaneID);

+

+__generic<T : __BuiltinType> T QuadSwapX(T localValue);

+__generic<T : __BuiltinType, let N : int> vector<T,N> QuadSwapX(vector<T,N> localValue);

+__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> QuadSwapX(matrix<T,N,M> localValue);

+

+__generic<T : __BuiltinType> T QuadSwapY(T localValue);

+__generic<T : __BuiltinType, let N : int> vector<T,N> QuadSwapY(vector<T,N> localValue);

+__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> QuadSwapY(matrix<T,N,M> localValue);

+

+__generic<T : __BuiltinIntegerType> T WaveAllBitAnd(T expr);

+__generic<T : __BuiltinIntegerType, let N : int> vector<T,N> WaveAllBitAnd(vector<T,N> expr);

+__generic<T : __BuiltinIntegerType, let N : int, let M : int> matrix<T,N,M> WaveAllBitAnd(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinIntegerType> T WaveAllBitOr(T expr);

+__generic<T : __BuiltinIntegerType, let N : int> vector<T,N> WaveAllBitOr(vector<T,N> expr);

+__generic<T : __BuiltinIntegerType, let N : int, let M : int> matrix<T,N,M> WaveAllBitOr(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinIntegerType> T WaveAllBitXor(T expr);

+__generic<T : __BuiltinIntegerType, let N : int> vector<T,N> WaveAllBitXor(vector<T,N> expr);

+__generic<T : __BuiltinIntegerType, let N : int, let M : int> matrix<T,N,M> WaveAllBitXor(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinArithmeticType> T WaveAllMax(T expr);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllMax(vector<T,N> expr);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllMax(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinArithmeticType> T WaveAllMin(T expr);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllMin(vector<T,N> expr);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllMin(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinArithmeticType> T WaveAllProduct(T expr);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllProduct(vector<T,N> expr);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllProduct(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinArithmeticType> T WaveAllSum(T expr);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WaveAllSum(vector<T,N> expr);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WaveAllSum(matrix<T,N,M> expr);

+

+bool WaveAllEqual(bool expr);

+bool WaveAllTrue(bool expr);

+bool WaveAnyTrue(bool expr);

+

+uint64_t WaveBallot(bool expr);

+

+uint WaveGetLaneCount();

+uint WaveGetLaneIndex();

+uint WaveGetOrderedIndex();

+

+bool WaveIsHelperLane();

+

+bool WaveOnce();

+

+__generic<T : __BuiltinArithmeticType> T WavePrefixProduct(T expr);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WavePrefixProduct(vector<T,N> expr);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WavePrefixProduct(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinArithmeticType> T WavePrefixSum(T expr);

+__generic<T : __BuiltinArithmeticType, let N : int> vector<T,N> WavePrefixSum(vector<T,N> expr);

+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> matrix<T,N,M> WavePrefixSum(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinType> T WaveReadFirstLane(T expr);

+__generic<T : __BuiltinType, let N : int> vector<T,N> WaveReadFirstLane(vector<T,N> expr);

+__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> WaveReadFirstLane(matrix<T,N,M> expr);

+

+__generic<T : __BuiltinType> T WaveReadLaneAt(T expr, int laneIndex);

+__generic<T : __BuiltinType, let N : int> vector<T,N> WaveReadLaneAt(vector<T,N> expr, int laneIndex);

+__generic<T : __BuiltinType, let N : int, let M : int> matrix<T,N,M> WaveReadLaneAt(matrix<T,N,M> expr, int laneIndex);

+

+// `typedef`s to help with the fact that HLSL has been sorta-kinda case insensitive at various points

+typedef Texture2D texture2D;

+

+${{{{

+// Component-wise multiplication ops

+for(auto op : binaryOps)

+{

+    switch (op.opCode)

+    {

+    default:

+        continue;

+

+    case kIROp_Mul:

+    case kIRPseudoOp_MulAssign:

+        break;

+    }

+

+    for (auto type : kBaseTypes)

+    {

+        if ((type.flags & op.flags) == 0)

+            continue;

+

+        char const* leftType = type.name;

+        char const* rightType = leftType;

+        char const* resultType = leftType;

+

+        char const* leftQual = "";

+        if(op.flags & ASSIGNMENT) leftQual = "in out ";

+

+        sb << "__generic<let N : int, let M : int> ";

+        sb << "__intrinsic_op(" << int(op.opCode) << ") matrix<" << resultType << ",N,M> operator" << op.opName << "(" << leftQual << "matrix<" << leftType << ",N,M> left, matrix<" << rightType << ",N,M> right);\n";

+    }

+}

+

+//

+

+// Buffer types

+

+static const struct {

+    char const*         name;

+    SlangResourceAccess access;

+} kBaseBufferAccessLevels[] = {

+    { "",                   SLANG_RESOURCE_ACCESS_READ },

+    { "RW",                 SLANG_RESOURCE_ACCESS_READ_WRITE },

+    { "RasterizerOrdered",  SLANG_RESOURCE_ACCESS_RASTER_ORDERED },

+};

+static const int kBaseBufferAccessLevelCount = sizeof(kBaseBufferAccessLevels) / sizeof(kBaseBufferAccessLevels[0]);

+

+for (int aa = 0; aa < kBaseBufferAccessLevelCount; ++aa)

+{

+    auto flavor = TextureFlavor::create(TextureFlavor::Shape::ShapeBuffer, kBaseBufferAccessLevels[aa].access).flavor;

+    sb << "__generic<T>\n";

+    sb << "__magic_type(Texture," << int(flavor) << ")\n";

+    sb << "__intrinsic_type(" << (kIROp_TextureType + (int(flavor) << kIROpMeta_OtherShift)) << ")\n";

+    sb << "struct ";

+    sb << kBaseBufferAccessLevels[aa].name;

+    sb << "Buffer {\n";

+

+    sb << "void GetDimensions(out uint dim);\n";

+

+    sb << "__glsl_extension(GL_EXT_samplerless_texture_functions)";

+    sb << "__target_intrinsic(glsl, \"texelFetch($0, $1)$z\")\n";

+    sb << "T Load(int location);\n";

+

+    sb << "T Load(int location, out uint status);\n";

+

+    sb << "__subscript(uint index) -> T {\n";

+

+    sb << "__glsl_extension(GL_EXT_samplerless_texture_functions)";

+    sb << "__target_intrinsic(glsl, \"texelFetch($0, int($1))$z\") get;\n";

+

+    if (kBaseBufferAccessLevels[aa].access != SLANG_RESOURCE_ACCESS_READ)

+    {

+        sb << "ref;\n";

+    }

+

+    sb << "}\n";

+

+    sb << "};\n";

+}

+}}}}

+

+

+// DirectX Raytracing (DXR) Support

+//

+// The following is based on the experimental DXR SDK v0.09.01.

+//

+// Numbering follows the sections in the "D3D12 Raytracing Functional Spec" v0.09 (2018-03-12)

+//

+

+// 10.1.1 - Ray Flags

+

+typedef uint RAY_FLAG;

+

+static const RAY_FLAG RAY_FLAG_NONE                             = 0x00;

+static const RAY_FLAG RAY_FLAG_FORCE_OPAQUE                     = 0x01;

+static const RAY_FLAG RAY_FLAG_FORCE_NON_OPAQUE                 = 0x02;

+static const RAY_FLAG RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH  = 0x04;

+static const RAY_FLAG RAY_FLAG_SKIP_CLOSEST_HIT_SHADER          = 0x08;

+static const RAY_FLAG RAY_FLAG_CULL_BACK_FACING_TRIANGLES       = 0x10;

+static const RAY_FLAG RAY_FLAG_CULL_FRONT_FACING_TRIANGLES      = 0x20;

+static const RAY_FLAG RAY_FLAG_CULL_OPAQUE                      = 0x40;

+static const RAY_FLAG RAY_FLAG_CULL_NON_OPAQUE                  = 0x80;

+

+// 10.1.2 - Ray Description Structure

+

+__builtin

+__magic_type(RayDescType)

+__intrinsic_type($(kIROp_RayDescType))

+struct RayDesc

+{

+    __target_intrinsic(hlsl, Origin)

+    float3 Origin;

+

+    __target_intrinsic(hlsl, TMin)

+    float  TMin;

+

+    __target_intrinsic(hlsl, Direction)

+    float3 Direction;

+

+    __target_intrinsic(hlsl, TMax)

+    float  TMax;

+};

+

+// 10.1.3 - Ray Acceleration Structure

+

+__builtin

+__magic_type(RaytracingAccelerationStructureType)

+__intrinsic_type($(kIROp_RaytracingAccelerationStructureType))

+struct RaytracingAccelerationStructure {};

+

+// 10.1.4 - Subobject Definitions

+

+// TODO: We may decide to support these, but their reliance on C++ implicit

+// constructor call syntax (`SomeType someVar(arg0, arg1);`) makes them

+// annoying for the current Slang parsing strategy, and using global variables

+// for this stuff comes across as a kludge rather than the best possible design.

+

+// 10.1.5 - Intersection Attributes Structure

+

+__builtin

+__magic_type(BuiltInTriangleIntersectionAttributesType)

+__intrinsic_type($(kIROp_BuiltInTriangleIntersectionAttributesType))

+struct BuiltInTriangleIntersectionAttributes

+{

+    __target_intrinsic(hlsl, barycentrics)

+    float2 barycentrics;

+};

+

+// 10.2 Shaders

+

+// Right now new shader stages need to be added directly to the compiler

+// implementation, rather than being something that can be declared in the stdlib.

+

+// 10.3 - Intrinsics

+

+// 10.3.1

+void CallShader<param_t>(uint ShaderIndex, inout param_t Parameter);

+

+// 10.3.2

+void TraceRay<payload_t>(

+    RaytracingAccelerationStructure AccelerationStructure,

+    uint                            RayFlags,

+    uint                            InstanceInclusionMask,

+    uint                            RayContributionToHitGroupIndex,

+    uint                            MultiplierForGeometryContributionToHitGroupIndex,

+    uint                            MissShaderIndex,

+    RayDesc                         Ray,

+    inout payload_t                 Payload);

+

+// 10.3.3

+bool ReportHit<attr_t>(float THit, uint HitKind, attr_t Attributes);

+

+// 10.3.4

+void IgnoreHit();

+

+// 10.3.5

+void AcceptHitAndEndSearch();

+

+// 10.4 - System Values and Special Semantics

+

+// TODO: Many of these functions need to be restricted so that

+// they can only be accessed from specific stages.

+

+// 10.4.1 - Ray Dispatch System Values

+uint3 DispatchRaysIndex();

+uint3 DispatchRaysDimensions();

+

+// 10.4.2 - Ray System Values

+float3 WorldRayOrigin();

+float3 WorldRayDirection();

+float RayTMin();

+float RayTCurrent();

+uint RayFlags();

+

+// 10.4.3 - Primitive/Object Space System Values

+uint InstanceIndex();

+uint InstanceID();

+uint PrimitiveIndex();

+float3 ObjectRayOrigin();

+float3 ObjectRayDirection();

+

+float3x4 ObjectToWorld3x4();

+float4x3 ObjectToWorld4x3();

+float3x4 WorldToObject3x4();

+float4x3 WorldToObject4x3();


+// Note: The provisional DXR spec included these unadorned

+// `ObjectToWorld()` and `WorldToObject()` functions, so

+// we will forward them to the new names as a convience

+// for users who are porting their code.

+//

+// TODO: Should we provide a deprecation warning on these

+// declarations, so that users can know they aren't coding

+// against the final spec?

+//

+float3x4 ObjectToWorld() { return ObjectToWorld3x4(); }

+float3x4 WorldToObject() { return WorldToObject3x4(); }

+

+// 10.4.4 - Hit Specific System values

+uint HitKind();

diff --git a/source/slang/hlsl.meta.slang.h b/source/slang/hlsl.meta.slang.h
index 54aa2710d..21a9305f8 100644
--- a/source/slang/hlsl.meta.slang.h
+++ b/source/slang/hlsl.meta.slang.h
@@ -1436,8 +1436,8 @@ SLANG_RAW("// TODO: Many of these functions need to be restricted so that\n")
 SLANG_RAW("// they can only be accessed from specific stages.\n")
 SLANG_RAW("\n")
 SLANG_RAW("// 10.4.1 - Ray Dispatch System Values\n")
-SLANG_RAW("uint2 DispatchRaysIndex();\n")
-SLANG_RAW("uint2 DispatchRaysDimensions();\n")
+SLANG_RAW("uint3 DispatchRaysIndex();\n")
+SLANG_RAW("uint3 DispatchRaysDimensions();\n")
 SLANG_RAW("\n")
 SLANG_RAW("// 10.4.2 - Ray System Values\n")
 SLANG_RAW("float3 WorldRayOrigin();\n")
@@ -1452,8 +1452,23 @@ SLANG_RAW("uint InstanceID();\n")
 SLANG_RAW("uint PrimitiveIndex();\n")
 SLANG_RAW("float3 ObjectRayOrigin();\n")
 SLANG_RAW("float3 ObjectRayDirection();\n")
-SLANG_RAW("float3x4 ObjectToWorld();\n")
-SLANG_RAW("float3x4 WorldToObject();\n")
+SLANG_RAW("\n")
+SLANG_RAW("float3x4 ObjectToWorld3x4();\n")
+SLANG_RAW("float4x3 ObjectToWorld4x3();\n")
+SLANG_RAW("float3x4 WorldToObject3x4();\n")
+SLANG_RAW("float4x3 WorldToObject4x3();\n")
+SLANG_RAW("\n")
+SLANG_RAW("// Note: The provisional DXR spec included these unadorned\n")
+SLANG_RAW("// `ObjectToWorld()` and `WorldToObject()` functions, so\n")
+SLANG_RAW("// we will forward them to the new names as a convience\n")
+SLANG_RAW("// for users who are porting their code.\n")
+SLANG_RAW("//\n")
+SLANG_RAW("// TODO: Should we provide a deprecation warning on these\n")
+SLANG_RAW("// declarations, so that users can know they aren't coding\n")
+SLANG_RAW("// against the final spec?\n")
+SLANG_RAW("//\n")
+SLANG_RAW("float3x4 ObjectToWorld() { return ObjectToWorld3x4(); }\n")
+SLANG_RAW("float3x4 WorldToObject() { return WorldToObject3x4(); }\n")
 SLANG_RAW("\n")
 SLANG_RAW("// 10.4.4 - Hit Specific System values\n")
 SLANG_RAW("uint HitKind();\n")