|
| half | hlsl::abs (half) |
| |
| half2 | hlsl::abs (half2) |
| |
| half3 | hlsl::abs (half3) |
| |
| half4 | hlsl::abs (half4) |
| |
| int | hlsl::abs (int) |
| |
| int2 | hlsl::abs (int2) |
| |
| int3 | hlsl::abs (int3) |
| |
| int4 | hlsl::abs (int4) |
| |
| float | hlsl::abs (float) |
| |
| float2 | hlsl::abs (float2) |
| |
| float3 | hlsl::abs (float3) |
| |
| float4 | hlsl::abs (float4) |
| |
| int64_t | hlsl::abs (int64_t) |
| |
| int64_t2 | hlsl::abs (int64_t2) |
| |
| int64_t3 | hlsl::abs (int64_t3) |
| |
| int64_t4 | hlsl::abs (int64_t4) |
| |
| double | hlsl::abs (double) |
| |
| double2 | hlsl::abs (double2) |
| |
| double3 | hlsl::abs (double3) |
| |
| double4 | hlsl::abs (double4) |
| |
| float | hlsl::acos (float) |
| |
| float2 | hlsl::acos (float2) |
| |
| float3 | hlsl::acos (float3) |
| |
| float4 | hlsl::acos (float4) |
| |
| bool | hlsl::all (half) |
| |
| bool | hlsl::all (half2) |
| |
| bool | hlsl::all (half3) |
| |
| bool | hlsl::all (half4) |
| |
| bool | hlsl::all (bool) |
| |
| bool | hlsl::all (bool2) |
| |
| bool | hlsl::all (bool3) |
| |
| bool | hlsl::all (bool4) |
| |
| bool | hlsl::all (int) |
| |
| bool | hlsl::all (int2) |
| |
| bool | hlsl::all (int3) |
| |
| bool | hlsl::all (int4) |
| |
| bool | hlsl::all (uint) |
| |
| bool | hlsl::all (uint2) |
| |
| bool | hlsl::all (uint3) |
| |
| bool | hlsl::all (uint4) |
| |
| bool | hlsl::all (float) |
| |
| bool | hlsl::all (float2) |
| |
| bool | hlsl::all (float3) |
| |
| bool | hlsl::all (float4) |
| |
| bool | hlsl::all (int64_t) |
| |
| bool | hlsl::all (int64_t2) |
| |
| bool | hlsl::all (int64_t3) |
| |
| bool | hlsl::all (int64_t4) |
| |
| bool | hlsl::all (uint64_t) |
| |
| bool | hlsl::all (uint64_t2) |
| |
| bool | hlsl::all (uint64_t3) |
| |
| bool | hlsl::all (uint64_t4) |
| |
| bool | hlsl::all (double) |
| |
| bool | hlsl::all (double2) |
| |
| bool | hlsl::all (double3) |
| |
| bool | hlsl::all (double4) |
| |
| bool | hlsl::any (half) |
| |
| bool | hlsl::any (half2) |
| |
| bool | hlsl::any (half3) |
| |
| bool | hlsl::any (half4) |
| |
| bool | hlsl::any (bool) |
| |
| bool | hlsl::any (bool2) |
| |
| bool | hlsl::any (bool3) |
| |
| bool | hlsl::any (bool4) |
| |
| bool | hlsl::any (int) |
| |
| bool | hlsl::any (int2) |
| |
| bool | hlsl::any (int3) |
| |
| bool | hlsl::any (int4) |
| |
| bool | hlsl::any (uint) |
| |
| bool | hlsl::any (uint2) |
| |
| bool | hlsl::any (uint3) |
| |
| bool | hlsl::any (uint4) |
| |
| bool | hlsl::any (float) |
| |
| bool | hlsl::any (float2) |
| |
| bool | hlsl::any (float3) |
| |
| bool | hlsl::any (float4) |
| |
| bool | hlsl::any (int64_t) |
| |
| bool | hlsl::any (int64_t2) |
| |
| bool | hlsl::any (int64_t3) |
| |
| bool | hlsl::any (int64_t4) |
| |
| bool | hlsl::any (uint64_t) |
| |
| bool | hlsl::any (uint64_t2) |
| |
| bool | hlsl::any (uint64_t3) |
| |
| bool | hlsl::any (uint64_t4) |
| |
| bool | hlsl::any (double) |
| |
| bool | hlsl::any (double2) |
| |
| bool | hlsl::any (double3) |
| |
| bool | hlsl::any (double4) |
| |
| double | hlsl::asdouble (uint, uint) |
| | Reinterprets a cast value (two 32-bit values) into a double.
|
| |
| double2 | hlsl::asdouble (uint2, uint2) |
| |
| double3 | hlsl::asdouble (uint3, uint3) |
| |
| double4 | hlsl::asdouble (uint4, uint4) |
| |
| template<typename T , int N> |
| constexpr vector< float, N > | hlsl::asfloat (vector< T, N > V) |
| |
| template<typename T > |
| constexpr float | hlsl::asfloat (T F) |
| | Interprets the bit pattern of x as float point number.
|
| |
| template<typename T , int N> |
| constexpr vector< int, N > | hlsl::asint (vector< T, N > V) |
| |
| template<typename T > |
| constexpr int | hlsl::asint (T F) |
| | Interprets the bit pattern of x as an integer.
|
| |
| float | hlsl::asin (float) |
| |
| float2 | hlsl::asin (float2) |
| |
| float3 | hlsl::asin (float3) |
| |
| float4 | hlsl::asin (float4) |
| |
| template<typename T , int N> |
| constexpr vector< uint, N > | hlsl::asuint (vector< T, N > V) |
| |
| template<typename T > |
| constexpr uint | hlsl::asuint (T F) |
| | Interprets the bit pattern of x as an unsigned integer.
|
| |
| void | hlsl::asuint (double, out uint, out uint) |
| |
| void | hlsl::asuint (double2, out uint2, out uint2) |
| |
| void | hlsl::asuint (double3, out uint3, out uint3) |
| |
| void | hlsl::asuint (double4, out uint4, out uint4) |
| |
| float | hlsl::atan (float) |
| |
| float2 | hlsl::atan (float2) |
| |
| float3 | hlsl::atan (float3) |
| |
| float4 | hlsl::atan (float4) |
| |
| float | hlsl::atan2 (float y, float x) |
| |
| float2 | hlsl::atan2 (float2 y, float2 x) |
| |
| float3 | hlsl::atan2 (float3 y, float3 x) |
| |
| float4 | hlsl::atan2 (float4 y, float4 x) |
| |
| half | hlsl::ceil (half) |
| |
| half2 | hlsl::ceil (half2) |
| |
| half3 | hlsl::ceil (half3) |
| |
| half4 | hlsl::ceil (half4) |
| |
| float | hlsl::ceil (float) |
| |
| float2 | hlsl::ceil (float2) |
| |
| float3 | hlsl::ceil (float3) |
| |
| float4 | hlsl::ceil (float4) |
| |
| half | hlsl::clamp (half, half, half) |
| |
| half2 | hlsl::clamp (half2, half2, half2) |
| |
| half3 | hlsl::clamp (half3, half3, half3) |
| |
| half4 | hlsl::clamp (half4, half4, half4) |
| |
| int | hlsl::clamp (int, int, int) |
| |
| int2 | hlsl::clamp (int2, int2, int2) |
| |
| int3 | hlsl::clamp (int3, int3, int3) |
| |
| int4 | hlsl::clamp (int4, int4, int4) |
| |
| uint | hlsl::clamp (uint, uint, uint) |
| |
| uint2 | hlsl::clamp (uint2, uint2, uint2) |
| |
| uint3 | hlsl::clamp (uint3, uint3, uint3) |
| |
| uint4 | hlsl::clamp (uint4, uint4, uint4) |
| |
| int64_t | hlsl::clamp (int64_t, int64_t, int64_t) |
| |
| int64_t2 | hlsl::clamp (int64_t2, int64_t2, int64_t2) |
| |
| int64_t3 | hlsl::clamp (int64_t3, int64_t3, int64_t3) |
| |
| int64_t4 | hlsl::clamp (int64_t4, int64_t4, int64_t4) |
| |
| uint64_t | hlsl::clamp (uint64_t, uint64_t, uint64_t) |
| |
| uint64_t2 | hlsl::clamp (uint64_t2, uint64_t2, uint64_t2) |
| |
| uint64_t3 | hlsl::clamp (uint64_t3, uint64_t3, uint64_t3) |
| |
| uint64_t4 | hlsl::clamp (uint64_t4, uint64_t4, uint64_t4) |
| |
| float | hlsl::clamp (float, float, float) |
| |
| float2 | hlsl::clamp (float2, float2, float2) |
| |
| float3 | hlsl::clamp (float3, float3, float3) |
| |
| float4 | hlsl::clamp (float4, float4, float4) |
| |
| double | hlsl::clamp (double, double, double) |
| |
| double2 | hlsl::clamp (double2, double2, double2) |
| |
| double3 | hlsl::clamp (double3, double3, double3) |
| |
| double4 | hlsl::clamp (double4, double4, double4) |
| |
| void | hlsl::clip (float) |
| |
| void | hlsl::clip (float2) |
| |
| void | hlsl::clip (float3) |
| |
| void | hlsl::clip (float4) |
| |
| half | hlsl::cos (half) |
| |
| half2 | hlsl::cos (half2) |
| |
| half3 | hlsl::cos (half3) |
| |
| half4 | hlsl::cos (half4) |
| |
| float | hlsl::cos (float) |
| |
| float2 | hlsl::cos (float2) |
| |
| float3 | hlsl::cos (float3) |
| |
| float4 | hlsl::cos (float4) |
| |
| float | hlsl::cosh (float) |
| |
| float2 | hlsl::cosh (float2) |
| |
| float3 | hlsl::cosh (float3) |
| |
| float4 | hlsl::cosh (float4) |
| |
| const uint | hlsl::countbits (int x) |
| |
| const uint2 | hlsl::countbits (int2 x) |
| |
| const uint3 | hlsl::countbits (int3 x) |
| |
| const uint4 | hlsl::countbits (int4 x) |
| |
| const uint | hlsl::countbits (uint x) |
| |
| const uint2 | hlsl::countbits (uint2 x) |
| |
| const uint3 | hlsl::countbits (uint3 x) |
| |
| const uint4 | hlsl::countbits (uint4 x) |
| |
| const uint | hlsl::countbits (int64_t x) |
| |
| const uint2 | hlsl::countbits (int64_t2 x) |
| |
| const uint3 | hlsl::countbits (int64_t3 x) |
| |
| const uint4 | hlsl::countbits (int64_t4 x) |
| |
| const uint | hlsl::countbits (uint64_t x) |
| |
| const uint2 | hlsl::countbits (uint64_t2 x) |
| |
| const uint3 | hlsl::countbits (uint64_t3 x) |
| |
| const uint4 | hlsl::countbits (uint64_t4 x) |
| |
| half | hlsl::degrees (half) |
| |
| half2 | hlsl::degrees (half2) |
| |
| half3 | hlsl::degrees (half3) |
| |
| half4 | hlsl::degrees (half4) |
| |
| float | hlsl::degrees (float) |
| |
| float2 | hlsl::degrees (float2) |
| |
| float3 | hlsl::degrees (float3) |
| |
| float4 | hlsl::degrees (float4) |
| |
| half | hlsl::dot (half, half) |
| |
| half | hlsl::dot (half2, half2) |
| |
| half | hlsl::dot (half3, half3) |
| |
| half | hlsl::dot (half4, half4) |
| |
| float | hlsl::dot (float, float) |
| |
| float | hlsl::dot (float2, float2) |
| |
| float | hlsl::dot (float3, float3) |
| |
| float | hlsl::dot (float4, float4) |
| |
| double | hlsl::dot (double, double) |
| |
| int | hlsl::dot (int, int) |
| |
| int | hlsl::dot (int2, int2) |
| |
| int | hlsl::dot (int3, int3) |
| |
| int | hlsl::dot (int4, int4) |
| |
| uint | hlsl::dot (uint, uint) |
| |
| uint | hlsl::dot (uint2, uint2) |
| |
| uint | hlsl::dot (uint3, uint3) |
| |
| uint | hlsl::dot (uint4, uint4) |
| |
| int64_t | hlsl::dot (int64_t, int64_t) |
| |
| int64_t | hlsl::dot (int64_t2, int64_t2) |
| |
| int64_t | hlsl::dot (int64_t3, int64_t3) |
| |
| int64_t | hlsl::dot (int64_t4, int64_t4) |
| |
| uint64_t | hlsl::dot (uint64_t, uint64_t) |
| |
| uint64_t | hlsl::dot (uint64_t2, uint64_t2) |
| |
| uint64_t | hlsl::dot (uint64_t3, uint64_t3) |
| |
| uint64_t | hlsl::dot (uint64_t4, uint64_t4) |
| |
| int | hlsl::dot4add_i8packed (uint, uint, int) |
| |
| uint | hlsl::dot4add_u8packed (uint, uint, uint) |
| |
| half | hlsl::exp (half) |
| |
| half2 | hlsl::exp (half2) |
| |
| half3 | hlsl::exp (half3) |
| |
| half4 | hlsl::exp (half4) |
| |
| float | hlsl::exp (float) |
| |
| float2 | hlsl::exp (float2) |
| |
| float3 | hlsl::exp (float3) |
| |
| float4 | hlsl::exp (float4) |
| |
| half | hlsl::exp2 (half) |
| |
| half2 | hlsl::exp2 (half2) |
| |
| half3 | hlsl::exp2 (half3) |
| |
| half4 | hlsl::exp2 (half4) |
| |
| float | hlsl::exp2 (float) |
| |
| float2 | hlsl::exp2 (float2) |
| |
| float3 | hlsl::exp2 (float3) |
| |
| float4 | hlsl::exp2 (float4) |
| |
| uint | hlsl::firstbithigh (int) |
| |
| uint2 | hlsl::firstbithigh (int2) |
| |
| uint3 | hlsl::firstbithigh (int3) |
| |
| uint4 | hlsl::firstbithigh (int4) |
| |
| uint | hlsl::firstbithigh (uint) |
| |
| uint2 | hlsl::firstbithigh (uint2) |
| |
| uint3 | hlsl::firstbithigh (uint3) |
| |
| uint4 | hlsl::firstbithigh (uint4) |
| |
| uint | hlsl::firstbithigh (int64_t) |
| |
| uint2 | hlsl::firstbithigh (int64_t2) |
| |
| uint3 | hlsl::firstbithigh (int64_t3) |
| |
| uint4 | hlsl::firstbithigh (int64_t4) |
| |
| uint | hlsl::firstbithigh (uint64_t) |
| |
| uint2 | hlsl::firstbithigh (uint64_t2) |
| |
| uint3 | hlsl::firstbithigh (uint64_t3) |
| |
| uint4 | hlsl::firstbithigh (uint64_t4) |
| |
| half | hlsl::floor (half) |
| |
| half2 | hlsl::floor (half2) |
| |
| half3 | hlsl::floor (half3) |
| |
| half4 | hlsl::floor (half4) |
| |
| float | hlsl::floor (float) |
| |
| float2 | hlsl::floor (float2) |
| |
| float3 | hlsl::floor (float3) |
| |
| float4 | hlsl::floor (float4) |
| |
| half | hlsl::fmod (half, half) |
| |
| half2 | hlsl::fmod (half2, half2) |
| |
| half3 | hlsl::fmod (half3, half3) |
| |
| half4 | hlsl::fmod (half4, half4) |
| |
| float | hlsl::fmod (float, float) |
| |
| float2 | hlsl::fmod (float2, float2) |
| |
| float3 | hlsl::fmod (float3, float3) |
| |
| float4 | hlsl::fmod (float4, float4) |
| |
| half | hlsl::frac (half) |
| |
| half2 | hlsl::frac (half2) |
| |
| half3 | hlsl::frac (half3) |
| |
| half4 | hlsl::frac (half4) |
| |
| float | hlsl::frac (float) |
| |
| float2 | hlsl::frac (float2) |
| |
| float3 | hlsl::frac (float3) |
| |
| float4 | hlsl::frac (float4) |
| |
| bool | hlsl::isinf (half) |
| |
| bool2 | hlsl::isinf (half2) |
| |
| bool3 | hlsl::isinf (half3) |
| |
| bool4 | hlsl::isinf (half4) |
| |
| bool | hlsl::isinf (float) |
| |
| bool2 | hlsl::isinf (float2) |
| |
| bool3 | hlsl::isinf (float3) |
| |
| bool4 | hlsl::isinf (float4) |
| |
| half | hlsl::lerp (half, half, half) |
| |
| half2 | hlsl::lerp (half2, half2, half2) |
| |
| half3 | hlsl::lerp (half3, half3, half3) |
| |
| half4 | hlsl::lerp (half4, half4, half4) |
| |
| float | hlsl::lerp (float, float, float) |
| |
| float2 | hlsl::lerp (float2, float2, float2) |
| |
| float3 | hlsl::lerp (float3, float3, float3) |
| |
| float4 | hlsl::lerp (float4, float4, float4) |
| |
| half | hlsl::length (half) |
| |
| half | hlsl::length (half2) |
| |
| half | hlsl::length (half3) |
| |
| half | hlsl::length (half4) |
| |
| float | hlsl::length (float) |
| |
| float | hlsl::length (float2) |
| |
| float | hlsl::length (float3) |
| |
| float | hlsl::length (float4) |
| |
| half | hlsl::log (half) |
| |
| half2 | hlsl::log (half2) |
| |
| half3 | hlsl::log (half3) |
| |
| half4 | hlsl::log (half4) |
| |
| float | hlsl::log (float) |
| |
| float2 | hlsl::log (float2) |
| |
| float3 | hlsl::log (float3) |
| |
| float4 | hlsl::log (float4) |
| |
| half | hlsl::log10 (half) |
| |
| half2 | hlsl::log10 (half2) |
| |
| half3 | hlsl::log10 (half3) |
| |
| half4 | hlsl::log10 (half4) |
| |
| float | hlsl::log10 (float) |
| |
| float2 | hlsl::log10 (float2) |
| |
| float3 | hlsl::log10 (float3) |
| |
| float4 | hlsl::log10 (float4) |
| |
| half | hlsl::log2 (half) |
| |
| half2 | hlsl::log2 (half2) |
| |
| half3 | hlsl::log2 (half3) |
| |
| half4 | hlsl::log2 (half4) |
| |
| float | hlsl::log2 (float) |
| |
| float2 | hlsl::log2 (float2) |
| |
| float3 | hlsl::log2 (float3) |
| |
| float4 | hlsl::log2 (float4) |
| |
| half | hlsl::mad (half, half, half) |
| |
| half2 | hlsl::mad (half2, half2, half2) |
| |
| half3 | hlsl::mad (half3, half3, half3) |
| |
| half4 | hlsl::mad (half4, half4, half4) |
| |
| int | hlsl::mad (int, int, int) |
| |
| int2 | hlsl::mad (int2, int2, int2) |
| |
| int3 | hlsl::mad (int3, int3, int3) |
| |
| int4 | hlsl::mad (int4, int4, int4) |
| |
| uint | hlsl::mad (uint, uint, uint) |
| |
| uint2 | hlsl::mad (uint2, uint2, uint2) |
| |
| uint3 | hlsl::mad (uint3, uint3, uint3) |
| |
| uint4 | hlsl::mad (uint4, uint4, uint4) |
| |
| int64_t | hlsl::mad (int64_t, int64_t, int64_t) |
| |
| int64_t2 | hlsl::mad (int64_t2, int64_t2, int64_t2) |
| |
| int64_t3 | hlsl::mad (int64_t3, int64_t3, int64_t3) |
| |
| int64_t4 | hlsl::mad (int64_t4, int64_t4, int64_t4) |
| |
| uint64_t | hlsl::mad (uint64_t, uint64_t, uint64_t) |
| |
| uint64_t2 | hlsl::mad (uint64_t2, uint64_t2, uint64_t2) |
| |
| uint64_t3 | hlsl::mad (uint64_t3, uint64_t3, uint64_t3) |
| |
| uint64_t4 | hlsl::mad (uint64_t4, uint64_t4, uint64_t4) |
| |
| float | hlsl::mad (float, float, float) |
| |
| float2 | hlsl::mad (float2, float2, float2) |
| |
| float3 | hlsl::mad (float3, float3, float3) |
| |
| float4 | hlsl::mad (float4, float4, float4) |
| |
| double | hlsl::mad (double, double, double) |
| |
| double2 | hlsl::mad (double2, double2, double2) |
| |
| double3 | hlsl::mad (double3, double3, double3) |
| |
| double4 | hlsl::mad (double4, double4, double4) |
| |
| half | hlsl::max (half, half) |
| |
| half2 | hlsl::max (half2, half2) |
| |
| half3 | hlsl::max (half3, half3) |
| |
| half4 | hlsl::max (half4, half4) |
| |
| int | hlsl::max (int, int) |
| |
| int2 | hlsl::max (int2, int2) |
| |
| int3 | hlsl::max (int3, int3) |
| |
| int4 | hlsl::max (int4, int4) |
| |
| uint | hlsl::max (uint, uint) |
| |
| uint2 | hlsl::max (uint2, uint2) |
| |
| uint3 | hlsl::max (uint3, uint3) |
| |
| uint4 | hlsl::max (uint4, uint4) |
| |
| int64_t | hlsl::max (int64_t, int64_t) |
| |
| int64_t2 | hlsl::max (int64_t2, int64_t2) |
| |
| int64_t3 | hlsl::max (int64_t3, int64_t3) |
| |
| int64_t4 | hlsl::max (int64_t4, int64_t4) |
| |
| uint64_t | hlsl::max (uint64_t, uint64_t) |
| |
| uint64_t2 | hlsl::max (uint64_t2, uint64_t2) |
| |
| uint64_t3 | hlsl::max (uint64_t3, uint64_t3) |
| |
| uint64_t4 | hlsl::max (uint64_t4, uint64_t4) |
| |
| float | hlsl::max (float, float) |
| |
| float2 | hlsl::max (float2, float2) |
| |
| float3 | hlsl::max (float3, float3) |
| |
| float4 | hlsl::max (float4, float4) |
| |
| double | hlsl::max (double, double) |
| |
| double2 | hlsl::max (double2, double2) |
| |
| double3 | hlsl::max (double3, double3) |
| |
| double4 | hlsl::max (double4, double4) |
| |
| half | hlsl::min (half, half) |
| |
| half2 | hlsl::min (half2, half2) |
| |
| half3 | hlsl::min (half3, half3) |
| |
| half4 | hlsl::min (half4, half4) |
| |
| int | hlsl::min (int, int) |
| |
| int2 | hlsl::min (int2, int2) |
| |
| int3 | hlsl::min (int3, int3) |
| |
| int4 | hlsl::min (int4, int4) |
| |
| uint | hlsl::min (uint, uint) |
| |
| uint2 | hlsl::min (uint2, uint2) |
| |
| uint3 | hlsl::min (uint3, uint3) |
| |
| uint4 | hlsl::min (uint4, uint4) |
| |
| float | hlsl::min (float, float) |
| |
| float2 | hlsl::min (float2, float2) |
| |
| float3 | hlsl::min (float3, float3) |
| |
| float4 | hlsl::min (float4, float4) |
| |
| int64_t | hlsl::min (int64_t, int64_t) |
| |
| int64_t2 | hlsl::min (int64_t2, int64_t2) |
| |
| int64_t3 | hlsl::min (int64_t3, int64_t3) |
| |
| int64_t4 | hlsl::min (int64_t4, int64_t4) |
| |
| uint64_t | hlsl::min (uint64_t, uint64_t) |
| |
| uint64_t2 | hlsl::min (uint64_t2, uint64_t2) |
| |
| uint64_t3 | hlsl::min (uint64_t3, uint64_t3) |
| |
| uint64_t4 | hlsl::min (uint64_t4, uint64_t4) |
| |
| double | hlsl::min (double, double) |
| |
| double2 | hlsl::min (double2, double2) |
| |
| double3 | hlsl::min (double3, double3) |
| |
| double4 | hlsl::min (double4, double4) |
| |
| half | hlsl::normalize (half) |
| |
| half2 | hlsl::normalize (half2) |
| |
| half3 | hlsl::normalize (half3) |
| |
| half4 | hlsl::normalize (half4) |
| |
| float | hlsl::normalize (float) |
| |
| float2 | hlsl::normalize (float2) |
| |
| float3 | hlsl::normalize (float3) |
| |
| float4 | hlsl::normalize (float4) |
| |
| half | hlsl::pow (half, half) |
| |
| half2 | hlsl::pow (half2, half2) |
| |
| half3 | hlsl::pow (half3, half3) |
| |
| half4 | hlsl::pow (half4, half4) |
| |
| float | hlsl::pow (float, float) |
| |
| float2 | hlsl::pow (float2, float2) |
| |
| float3 | hlsl::pow (float3, float3) |
| |
| float4 | hlsl::pow (float4, float4) |
| |
| uint | hlsl::reversebits (uint) |
| |
| uint2 | hlsl::reversebits (uint2) |
| |
| uint3 | hlsl::reversebits (uint3) |
| |
| uint4 | hlsl::reversebits (uint4) |
| |
| uint64_t | hlsl::reversebits (uint64_t) |
| |
| uint64_t2 | hlsl::reversebits (uint64_t2) |
| |
| uint64_t3 | hlsl::reversebits (uint64_t3) |
| |
| uint64_t4 | hlsl::reversebits (uint64_t4) |
| |
| half3 | hlsl::cross (half3, half3) |
| |
| float3 | hlsl::cross (float3, float3) |
| |
| half | hlsl::rcp (half) |
| |
| half2 | hlsl::rcp (half2) |
| |
| half3 | hlsl::rcp (half3) |
| |
| half4 | hlsl::rcp (half4) |
| |
| float | hlsl::rcp (float) |
| |
| float2 | hlsl::rcp (float2) |
| |
| float3 | hlsl::rcp (float3) |
| |
| float4 | hlsl::rcp (float4) |
| |
| double | hlsl::rcp (double) |
| |
| double2 | hlsl::rcp (double2) |
| |
| double3 | hlsl::rcp (double3) |
| |
| double4 | hlsl::rcp (double4) |
| |
| half | hlsl::rsqrt (half) |
| |
| half2 | hlsl::rsqrt (half2) |
| |
| half3 | hlsl::rsqrt (half3) |
| |
| half4 | hlsl::rsqrt (half4) |
| |
| float | hlsl::rsqrt (float) |
| |
| float2 | hlsl::rsqrt (float2) |
| |
| float3 | hlsl::rsqrt (float3) |
| |
| float4 | hlsl::rsqrt (float4) |
| |
| half | hlsl::round (half) |
| |
| half2 | hlsl::round (half2) |
| |
| half3 | hlsl::round (half3) |
| |
| half4 | hlsl::round (half4) |
| |
| float | hlsl::round (float) |
| |
| float2 | hlsl::round (float2) |
| |
| float3 | hlsl::round (float3) |
| |
| float4 | hlsl::round (float4) |
| |
| half | hlsl::saturate (half) |
| |
| half2 | hlsl::saturate (half2) |
| |
| half3 | hlsl::saturate (half3) |
| |
| half4 | hlsl::saturate (half4) |
| |
| float | hlsl::saturate (float) |
| |
| float2 | hlsl::saturate (float2) |
| |
| float3 | hlsl::saturate (float3) |
| |
| float4 | hlsl::saturate (float4) |
| |
| double | hlsl::saturate (double) |
| |
| double2 | hlsl::saturate (double2) |
| |
| double3 | hlsl::saturate (double3) |
| |
| double4 | hlsl::saturate (double4) |
| |
| template<typename T > |
| T | hlsl::select (bool, T, T) |
| | ternary operator.
|
| |
| template<typename T , int Sz> |
| vector< T, Sz > | hlsl::select (vector< bool, Sz >, vector< T, Sz >, vector< T, Sz >) |
| | ternary operator for vectors.
|
| |
| half | hlsl::sin (half) |
| |
| half2 | hlsl::sin (half2) |
| |
| half3 | hlsl::sin (half3) |
| |
| half4 | hlsl::sin (half4) |
| |
| float | hlsl::sin (float) |
| |
| float2 | hlsl::sin (float2) |
| |
| float3 | hlsl::sin (float3) |
| |
| float4 | hlsl::sin (float4) |
| |
| float | hlsl::sinh (float) |
| |
| float2 | hlsl::sinh (float2) |
| |
| float3 | hlsl::sinh (float3) |
| |
| float4 | hlsl::sinh (float4) |
| |
| half | hlsl::sqrt (half) |
| |
| half2 | hlsl::sqrt (half2) |
| |
| half3 | hlsl::sqrt (half3) |
| |
| half4 | hlsl::sqrt (half4) |
| |
| float | hlsl::sqrt (float) |
| |
| float2 | hlsl::sqrt (float2) |
| |
| float3 | hlsl::sqrt (float3) |
| |
| float4 | hlsl::sqrt (float4) |
| |
| half | hlsl::step (half, half) |
| |
| half2 | hlsl::step (half2, half2) |
| |
| half3 | hlsl::step (half3, half3) |
| |
| half4 | hlsl::step (half4, half4) |
| |
| float | hlsl::step (float, float) |
| |
| float2 | hlsl::step (float2, float2) |
| |
| float3 | hlsl::step (float3, float3) |
| |
| float4 | hlsl::step (float4, float4) |
| |
| float | hlsl::tan (float) |
| |
| float2 | hlsl::tan (float2) |
| |
| float3 | hlsl::tan (float3) |
| |
| float4 | hlsl::tan (float4) |
| |
| float | hlsl::tanh (float) |
| |
| float2 | hlsl::tanh (float2) |
| |
| float3 | hlsl::tanh (float3) |
| |
| float4 | hlsl::tanh (float4) |
| |
| half | hlsl::trunc (half) |
| |
| half2 | hlsl::trunc (half2) |
| |
| half3 | hlsl::trunc (half3) |
| |
| half4 | hlsl::trunc (half4) |
| |
| float | hlsl::trunc (float) |
| |
| float2 | hlsl::trunc (float2) |
| |
| float3 | hlsl::trunc (float3) |
| |
| float4 | hlsl::trunc (float4) |
| |
| | hlsl::__attribute__ ((convergent)) bool WaveActiveAllTrue(bool Val) |
| | Returns true if the expression is true in all active lanes in the current wave.
|
| |
| int | hlsl::sign (half) |
| |
| int2 | hlsl::sign (half2) |
| |
| int3 | hlsl::sign (half3) |
| |
| int4 | hlsl::sign (half4) |
| |
| int | hlsl::sign (int) |
| |
| int2 | hlsl::sign (int2) |
| |
| int3 | hlsl::sign (int3) |
| |
| int4 | hlsl::sign (int4) |
| |
| int | hlsl::sign (uint) |
| |
| int2 | hlsl::sign (uint2) |
| |
| int3 | hlsl::sign (uint3) |
| |
| int4 | hlsl::sign (uint4) |
| |
| int | hlsl::sign (float) |
| |
| int2 | hlsl::sign (float2) |
| |
| int3 | hlsl::sign (float3) |
| |
| int4 | hlsl::sign (float4) |
| |
| int | hlsl::sign (int64_t) |
| |
| int2 | hlsl::sign (int64_t2) |
| |
| int3 | hlsl::sign (int64_t3) |
| |
| int4 | hlsl::sign (int64_t4) |
| |
| int | hlsl::sign (uint64_t) |
| |
| int2 | hlsl::sign (uint64_t2) |
| |
| int3 | hlsl::sign (uint64_t3) |
| |
| int4 | hlsl::sign (uint64_t4) |
| |
| int | hlsl::sign (double) |
| |
| int2 | hlsl::sign (double2) |
| |
| int3 | hlsl::sign (double3) |
| |
| int4 | hlsl::sign (double4) |
| |
| half | hlsl::radians (half) |
| |
| half2 | hlsl::radians (half2) |
| |
| half3 | hlsl::radians (half3) |
| |
| half4 | hlsl::radians (half4) |
| |
| float | hlsl::radians (float) |
| |
| float2 | hlsl::radians (float2) |
| |
| float3 | hlsl::radians (float3) |
| |
| float4 | hlsl::radians (float4) |
| |
| void | hlsl::GroupMemoryBarrierWithGroupSync (void) |
| | Blocks execution of all threads in a group until all group shared accesses have been completed and all threads in the group have reached this call.
|
| |
