521 lines · c
1//===--- hlsl_compat_overloads.h - Extra HLSL overloads for intrinsics ----===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef _HLSL_COMPAT_OVERLOADS_H_10#define _HLSL_COMPAT_OVERLOADS_H_11 12namespace hlsl {13 14// Note: Functions in this file are sorted alphabetically, then grouped by base15// element type, and the element types are sorted by size, then signed integer,16// unsigned integer and floating point. Keeping this ordering consistent will17// help keep this file manageable as it grows.18 19#define _DXC_DEPRECATED_64BIT_FN(fn) \20 [[deprecated("In 202x 64 bit API lowering for " #fn " is deprecated. " \21 "Explicitly cast parameters to 32 or 16 bit types.")]]22 23#define _DXC_DEPRECATED_INT_FN(fn) \24 [[deprecated("In 202x int lowering for " #fn " is deprecated. " \25 "Explicitly cast parameters to float types.")]]26 27#define _DXC_DEPRECATED_VEC_SCALAR_FN(fn) \28 [[deprecated("In 202x mismatched vector/scalar lowering for " #fn " is " \29 "deprecated. Explicitly cast parameters.")]]30 31#define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn) \32 _DXC_DEPRECATED_64BIT_FN(fn) \33 constexpr float fn(double V) { return fn((float)V); } \34 _DXC_DEPRECATED_64BIT_FN(fn) \35 constexpr float2 fn(double2 V) { return fn((float2)V); } \36 _DXC_DEPRECATED_64BIT_FN(fn) \37 constexpr float3 fn(double3 V) { return fn((float3)V); } \38 _DXC_DEPRECATED_64BIT_FN(fn) \39 constexpr float4 fn(double4 V) { return fn((float4)V); }40 41#define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn) \42 _DXC_DEPRECATED_64BIT_FN(fn) \43 constexpr float fn(double V1, double V2) { \44 return fn((float)V1, (float)V2); \45 } \46 _DXC_DEPRECATED_64BIT_FN(fn) \47 constexpr float2 fn(double2 V1, double2 V2) { \48 return fn((float2)V1, (float2)V2); \49 } \50 _DXC_DEPRECATED_64BIT_FN(fn) \51 constexpr float3 fn(double3 V1, double3 V2) { \52 return fn((float3)V1, (float3)V2); \53 } \54 _DXC_DEPRECATED_64BIT_FN(fn) \55 constexpr float4 fn(double4 V1, double4 V2) { \56 return fn((float4)V1, (float4)V2); \57 }58 59#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn) \60 _DXC_DEPRECATED_64BIT_FN(fn) \61 constexpr float fn(double V1, double V2, double V3) { \62 return fn((float)V1, (float)V2, (float)V3); \63 } \64 _DXC_DEPRECATED_64BIT_FN(fn) \65 constexpr float2 fn(double2 V1, double2 V2, double2 V3) { \66 return fn((float2)V1, (float2)V2, (float2)V3); \67 } \68 _DXC_DEPRECATED_64BIT_FN(fn) \69 constexpr float3 fn(double3 V1, double3 V2, double3 V3) { \70 return fn((float3)V1, (float3)V2, (float3)V3); \71 } \72 _DXC_DEPRECATED_64BIT_FN(fn) \73 constexpr float4 fn(double4 V1, double4 V2, double4 V3) { \74 return fn((float4)V1, (float4)V2, (float4)V3); \75 }76 77#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn) \78 _DXC_DEPRECATED_INT_FN(fn) \79 constexpr float fn(int V) { return fn((float)V); } \80 _DXC_DEPRECATED_INT_FN(fn) \81 constexpr float2 fn(int2 V) { return fn((float2)V); } \82 _DXC_DEPRECATED_INT_FN(fn) \83 constexpr float3 fn(int3 V) { return fn((float3)V); } \84 _DXC_DEPRECATED_INT_FN(fn) \85 constexpr float4 fn(int4 V) { return fn((float4)V); } \86 _DXC_DEPRECATED_INT_FN(fn) \87 constexpr float fn(uint V) { return fn((float)V); } \88 _DXC_DEPRECATED_INT_FN(fn) \89 constexpr float2 fn(uint2 V) { return fn((float2)V); } \90 _DXC_DEPRECATED_INT_FN(fn) \91 constexpr float3 fn(uint3 V) { return fn((float3)V); } \92 _DXC_DEPRECATED_INT_FN(fn) \93 constexpr float4 fn(uint4 V) { return fn((float4)V); } \94 _DXC_DEPRECATED_INT_FN(fn) \95 constexpr float fn(int64_t V) { return fn((float)V); } \96 _DXC_DEPRECATED_INT_FN(fn) \97 constexpr float2 fn(int64_t2 V) { return fn((float2)V); } \98 _DXC_DEPRECATED_INT_FN(fn) \99 constexpr float3 fn(int64_t3 V) { return fn((float3)V); } \100 _DXC_DEPRECATED_INT_FN(fn) \101 constexpr float4 fn(int64_t4 V) { return fn((float4)V); } \102 _DXC_DEPRECATED_INT_FN(fn) \103 constexpr float fn(uint64_t V) { return fn((float)V); } \104 _DXC_DEPRECATED_INT_FN(fn) \105 constexpr float2 fn(uint64_t2 V) { return fn((float2)V); } \106 _DXC_DEPRECATED_INT_FN(fn) \107 constexpr float3 fn(uint64_t3 V) { return fn((float3)V); } \108 _DXC_DEPRECATED_INT_FN(fn) \109 constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }110 111#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn) \112 _DXC_DEPRECATED_INT_FN(fn) \113 constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); } \114 _DXC_DEPRECATED_INT_FN(fn) \115 constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \116 _DXC_DEPRECATED_INT_FN(fn) \117 constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \118 _DXC_DEPRECATED_INT_FN(fn) \119 constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \120 _DXC_DEPRECATED_INT_FN(fn) \121 constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); } \122 _DXC_DEPRECATED_INT_FN(fn) \123 constexpr float2 fn(uint2 V1, uint2 V2) { \124 return fn((float2)V1, (float2)V2); \125 } \126 _DXC_DEPRECATED_INT_FN(fn) \127 constexpr float3 fn(uint3 V1, uint3 V2) { \128 return fn((float3)V1, (float3)V2); \129 } \130 _DXC_DEPRECATED_INT_FN(fn) \131 constexpr float4 fn(uint4 V1, uint4 V2) { \132 return fn((float4)V1, (float4)V2); \133 } \134 _DXC_DEPRECATED_INT_FN(fn) \135 constexpr float fn(int64_t V1, int64_t V2) { \136 return fn((float)V1, (float)V2); \137 } \138 _DXC_DEPRECATED_INT_FN(fn) \139 constexpr float2 fn(int64_t2 V1, int64_t2 V2) { \140 return fn((float2)V1, (float2)V2); \141 } \142 _DXC_DEPRECATED_INT_FN(fn) \143 constexpr float3 fn(int64_t3 V1, int64_t3 V2) { \144 return fn((float3)V1, (float3)V2); \145 } \146 _DXC_DEPRECATED_INT_FN(fn) \147 constexpr float4 fn(int64_t4 V1, int64_t4 V2) { \148 return fn((float4)V1, (float4)V2); \149 } \150 _DXC_DEPRECATED_INT_FN(fn) \151 constexpr float fn(uint64_t V1, uint64_t V2) { \152 return fn((float)V1, (float)V2); \153 } \154 _DXC_DEPRECATED_INT_FN(fn) \155 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) { \156 return fn((float2)V1, (float2)V2); \157 } \158 _DXC_DEPRECATED_INT_FN(fn) \159 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) { \160 return fn((float3)V1, (float3)V2); \161 } \162 _DXC_DEPRECATED_INT_FN(fn) \163 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) { \164 return fn((float4)V1, (float4)V2); \165 }166 167#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn) \168 _DXC_DEPRECATED_INT_FN(fn) \169 constexpr float fn(int V1, int V2, int V3) { \170 return fn((float)V1, (float)V2, (float)V3); \171 } \172 _DXC_DEPRECATED_INT_FN(fn) \173 constexpr float2 fn(int2 V1, int2 V2, int2 V3) { \174 return fn((float2)V1, (float2)V2, (float2)V3); \175 } \176 _DXC_DEPRECATED_INT_FN(fn) \177 constexpr float3 fn(int3 V1, int3 V2, int3 V3) { \178 return fn((float3)V1, (float3)V2, (float3)V3); \179 } \180 _DXC_DEPRECATED_INT_FN(fn) \181 constexpr float4 fn(int4 V1, int4 V2, int4 V3) { \182 return fn((float4)V1, (float4)V2, (float4)V3); \183 } \184 _DXC_DEPRECATED_INT_FN(fn) \185 constexpr float fn(uint V1, uint V2, uint V3) { \186 return fn((float)V1, (float)V2, (float)V3); \187 } \188 _DXC_DEPRECATED_INT_FN(fn) \189 constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) { \190 return fn((float2)V1, (float2)V2, (float2)V3); \191 } \192 _DXC_DEPRECATED_INT_FN(fn) \193 constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) { \194 return fn((float3)V1, (float3)V2, (float3)V3); \195 } \196 _DXC_DEPRECATED_INT_FN(fn) \197 constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) { \198 return fn((float4)V1, (float4)V2, (float4)V3); \199 } \200 _DXC_DEPRECATED_INT_FN(fn) \201 constexpr float fn(int64_t V1, int64_t V2, int64_t V3) { \202 return fn((float)V1, (float)V2, (float)V3); \203 } \204 _DXC_DEPRECATED_INT_FN(fn) \205 constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) { \206 return fn((float2)V1, (float2)V2, (float2)V3); \207 } \208 _DXC_DEPRECATED_INT_FN(fn) \209 constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) { \210 return fn((float3)V1, (float3)V2, (float3)V3); \211 } \212 _DXC_DEPRECATED_INT_FN(fn) \213 constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) { \214 return fn((float4)V1, (float4)V2, (float4)V3); \215 } \216 _DXC_DEPRECATED_INT_FN(fn) \217 constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) { \218 return fn((float)V1, (float)V2, (float)V3); \219 } \220 _DXC_DEPRECATED_INT_FN(fn) \221 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) { \222 return fn((float2)V1, (float2)V2, (float2)V3); \223 } \224 _DXC_DEPRECATED_INT_FN(fn) \225 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) { \226 return fn((float3)V1, (float3)V2, (float3)V3); \227 } \228 _DXC_DEPRECATED_INT_FN(fn) \229 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) { \230 return fn((float4)V1, (float4)V2, (float4)V3); \231 }232 233//===----------------------------------------------------------------------===//234// acos builtins overloads235//===----------------------------------------------------------------------===//236 237_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(acos)238_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(acos)239 240//===----------------------------------------------------------------------===//241// asin builtins overloads242//===----------------------------------------------------------------------===//243 244_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(asin)245_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(asin)246 247//===----------------------------------------------------------------------===//248// atan builtins overloads249//===----------------------------------------------------------------------===//250 251_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(atan)252_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(atan)253 254//===----------------------------------------------------------------------===//255// atan2 builtins overloads256//===----------------------------------------------------------------------===//257 258_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(atan2)259_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(atan2)260 261//===----------------------------------------------------------------------===//262// ceil builtins overloads263//===----------------------------------------------------------------------===//264 265_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(ceil)266_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)267 268//===----------------------------------------------------------------------===//269// clamp builtins overloads270//===----------------------------------------------------------------------===//271 272template <typename T, uint N>273_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)274constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(275 vector<T, N> p0, vector<T, N> p1, T p2) {276 return clamp(p0, p1, (vector<T, N>)p2);277}278 279template <typename T, uint N>280_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)281constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(282 vector<T, N> p0, T p1, vector<T, N> p2) {283 return clamp(p0, (vector<T, N>)p1, p2);284}285 286template <typename T, uint N>287_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)288constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(289 vector<T, N> p0, T p1, T p2) {290 return clamp(p0, (vector<T, N>)p1, (vector<T, N>)p2);291}292 293//===----------------------------------------------------------------------===//294// cos builtins overloads295//===----------------------------------------------------------------------===//296 297_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cos)298_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cos)299 300//===----------------------------------------------------------------------===//301// cosh builtins overloads302//===----------------------------------------------------------------------===//303 304_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cosh)305_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cosh)306 307//===----------------------------------------------------------------------===//308// degrees builtins overloads309//===----------------------------------------------------------------------===//310 311_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(degrees)312_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(degrees)313 314//===----------------------------------------------------------------------===//315// exp builtins overloads316//===----------------------------------------------------------------------===//317 318_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp)319_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp)320 321//===----------------------------------------------------------------------===//322// exp2 builtins overloads323//===----------------------------------------------------------------------===//324 325_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp2)326_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp2)327 328//===----------------------------------------------------------------------===//329// floor builtins overloads330//===----------------------------------------------------------------------===//331 332_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(floor)333_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(floor)334 335//===----------------------------------------------------------------------===//336// frac builtins overloads337//===----------------------------------------------------------------------===//338 339_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(frac)340_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)341 342//===----------------------------------------------------------------------===//343// isinf builtins overloads344//===----------------------------------------------------------------------===//345 346_DXC_DEPRECATED_64BIT_FN(fn)347constexpr bool isinf(double V) { return isinf((float)V); }348_DXC_DEPRECATED_64BIT_FN(fn)349constexpr bool2 isinf(double2 V) { return isinf((float2)V); }350_DXC_DEPRECATED_64BIT_FN(fn)351constexpr bool3 isinf(double3 V) { return isinf((float3)V); }352_DXC_DEPRECATED_64BIT_FN(fn)353constexpr bool4 isinf(double4 V) { return isinf((float4)V); }354 355//===----------------------------------------------------------------------===//356// isnan builtins overloads357//===----------------------------------------------------------------------===//358 359constexpr bool isnan(double V) { return isnan((float)V); }360constexpr bool2 isnan(double2 V) { return isnan((float2)V); }361constexpr bool3 isnan(double3 V) { return isnan((float3)V); }362constexpr bool4 isnan(double4 V) { return isnan((float4)V); }363 364//===----------------------------------------------------------------------===//365// lerp builtins overloads366//===----------------------------------------------------------------------===//367 368template <typename T, uint N>369_DXC_DEPRECATED_VEC_SCALAR_FN(lerp)370constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> lerp(371 vector<T, N> x, vector<T, N> y, T s) {372 return lerp(x, y, (vector<T, N>)s);373}374 375_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(lerp)376_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(lerp)377 378//===----------------------------------------------------------------------===//379// log builtins overloads380//===----------------------------------------------------------------------===//381 382_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log)383_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log)384 385//===----------------------------------------------------------------------===//386// log10 builtins overloads387//===----------------------------------------------------------------------===//388 389_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log10)390_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log10)391 392//===----------------------------------------------------------------------===//393// log2 builtins overloads394//===----------------------------------------------------------------------===//395 396_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log2)397_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)398 399//===----------------------------------------------------------------------===//400// max builtins overloads401//===----------------------------------------------------------------------===//402 403template <typename T, uint N>404_DXC_DEPRECATED_VEC_SCALAR_FN(max)405constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(406 vector<T, N> p0, T p1) {407 return max(p0, (vector<T, N>)p1);408}409 410template <typename T, uint N>411_DXC_DEPRECATED_VEC_SCALAR_FN(max)412constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(413 T p0, vector<T, N> p1) {414 return max((vector<T, N>)p0, p1);415}416 417//===----------------------------------------------------------------------===//418// min builtins overloads419//===----------------------------------------------------------------------===//420 421template <typename T, uint N>422_DXC_DEPRECATED_VEC_SCALAR_FN(min)423constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(424 vector<T, N> p0, T p1) {425 return min(p0, (vector<T, N>)p1);426}427 428template <typename T, uint N>429_DXC_DEPRECATED_VEC_SCALAR_FN(min)430constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(431 T p0, vector<T, N> p1) {432 return min((vector<T, N>)p0, p1);433}434 435//===----------------------------------------------------------------------===//436// normalize builtins overloads437//===----------------------------------------------------------------------===//438 439_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(normalize)440_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(normalize)441 442//===----------------------------------------------------------------------===//443// pow builtins overloads444//===----------------------------------------------------------------------===//445 446_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(pow)447_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(pow)448 449//===----------------------------------------------------------------------===//450// rsqrt builtins overloads451//===----------------------------------------------------------------------===//452 453_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(rsqrt)454_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(rsqrt)455 456//===----------------------------------------------------------------------===//457// round builtins overloads458//===----------------------------------------------------------------------===//459 460_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(round)461_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(round)462 463//===----------------------------------------------------------------------===//464// sin builtins overloads465//===----------------------------------------------------------------------===//466 467_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sin)468_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sin)469 470//===----------------------------------------------------------------------===//471// sinh builtins overloads472//===----------------------------------------------------------------------===//473 474_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sinh)475_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sinh)476 477//===----------------------------------------------------------------------===//478// sqrt builtins overloads479//===----------------------------------------------------------------------===//480 481_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sqrt)482_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sqrt)483 484//===----------------------------------------------------------------------===//485// step builtins overloads486//===----------------------------------------------------------------------===//487 488_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(step)489_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(step)490 491//===----------------------------------------------------------------------===//492// tan builtins overloads493//===----------------------------------------------------------------------===//494 495_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tan)496_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tan)497 498//===----------------------------------------------------------------------===//499// tanh builtins overloads500//===----------------------------------------------------------------------===//501 502_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tanh)503_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tanh)504 505//===----------------------------------------------------------------------===//506// trunc builtins overloads507//===----------------------------------------------------------------------===//508 509_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(trunc)510_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(trunc)511 512//===----------------------------------------------------------------------===//513// radians builtins overloads514//===----------------------------------------------------------------------===//515 516_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(radians)517_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(radians)518 519} // namespace hlsl520#endif // _HLSL_COMPAT_OVERLOADS_H_521