|
| 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) |
| |
| float | hlsl::asin (float) |
| |
| float2 | hlsl::asin (float2) |
| |
| float3 | hlsl::asin (float3) |
| |
| float4 | hlsl::asin (float4) |
| |
| float | hlsl::atan (float) |
| |
| float2 | hlsl::atan (float2) |
| |
| float3 | hlsl::atan (float3) |
| |
| float4 | hlsl::atan (float4) |
| |
| 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) |
| |
| 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) |
| |
| 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) |
| |
| 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) |
| |
| 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::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) |
| |
| 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::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) |
| |
| 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)) uint WaveActiveCountBits(bool Val) |
| | Counts the number of boolean variables which evaluate to true across all active lanes in the current wave. More...
|
| |
