1 //===----- hlsl_intrinsics.h - HLSL definitions 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-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef _HLSL_HLSL_INTRINSICS_H_ 10 #define _HLSL_HLSL_INTRINSICS_H_ 11 12 #include "hlsl_detail.h" 13 14 namespace hlsl { 15 16 // Note: Functions in this file are sorted alphabetically, then grouped by base 17 // element type, and the element types are sorted by size, then singed integer, 18 // unsigned integer and floating point. Keeping this ordering consistent will 19 // help keep this file manageable as it grows. 20 21 #define _HLSL_BUILTIN_ALIAS(builtin) \ 22 __attribute__((clang_builtin_alias(builtin))) 23 #define _HLSL_AVAILABILITY(platform, version) \ 24 __attribute__((availability(platform, introduced = version))) 25 #define _HLSL_AVAILABILITY_STAGE(platform, version, stage) \ 26 __attribute__(( \ 27 availability(platform, introduced = version, environment = stage))) 28 29 #ifdef __HLSL_ENABLE_16_BIT 30 #define _HLSL_16BIT_AVAILABILITY(platform, version) \ 31 __attribute__((availability(platform, introduced = version))) 32 #define _HLSL_16BIT_AVAILABILITY_STAGE(platform, version, stage) \ 33 __attribute__(( \ 34 availability(platform, introduced = version, environment = stage))) 35 #else 36 #define _HLSL_16BIT_AVAILABILITY(environment, version) 37 #define _HLSL_16BIT_AVAILABILITY_STAGE(environment, version, stage) 38 #endif 39 40 //===----------------------------------------------------------------------===// 41 // abs builtins 42 //===----------------------------------------------------------------------===// 43 44 /// \fn T abs(T Val) 45 /// \brief Returns the absolute value of the input value, \a Val. 46 /// \param Val The input value. 47 48 #ifdef __HLSL_ENABLE_16_BIT 49 _HLSL_AVAILABILITY(shadermodel, 6.2) 50 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 51 int16_t abs(int16_t); 52 _HLSL_AVAILABILITY(shadermodel, 6.2) 53 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 54 int16_t2 abs(int16_t2); 55 _HLSL_AVAILABILITY(shadermodel, 6.2) 56 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 57 int16_t3 abs(int16_t3); 58 _HLSL_AVAILABILITY(shadermodel, 6.2) 59 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 60 int16_t4 abs(int16_t4); 61 #endif 62 63 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 64 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 65 half abs(half); 66 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 67 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 68 half2 abs(half2); 69 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 70 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 71 half3 abs(half3); 72 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 73 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 74 half4 abs(half4); 75 76 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 77 int abs(int); 78 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 79 int2 abs(int2); 80 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 81 int3 abs(int3); 82 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 83 int4 abs(int4); 84 85 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 86 float abs(float); 87 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 88 float2 abs(float2); 89 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 90 float3 abs(float3); 91 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 92 float4 abs(float4); 93 94 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 95 int64_t abs(int64_t); 96 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 97 int64_t2 abs(int64_t2); 98 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 99 int64_t3 abs(int64_t3); 100 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 101 int64_t4 abs(int64_t4); 102 103 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 104 double abs(double); 105 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 106 double2 abs(double2); 107 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 108 double3 abs(double3); 109 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) 110 double4 abs(double4); 111 112 //===----------------------------------------------------------------------===// 113 // acos builtins 114 //===----------------------------------------------------------------------===// 115 116 /// \fn T acos(T Val) 117 /// \brief Returns the arccosine of the input value, \a Val. 118 /// \param Val The input value. 119 120 #ifdef __HLSL_ENABLE_16_BIT 121 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 122 half acos(half); 123 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 124 half2 acos(half2); 125 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 126 half3 acos(half3); 127 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 128 half4 acos(half4); 129 #endif 130 131 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 132 float acos(float); 133 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 134 float2 acos(float2); 135 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 136 float3 acos(float3); 137 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_acos) 138 float4 acos(float4); 139 140 //===----------------------------------------------------------------------===// 141 // all builtins 142 //===----------------------------------------------------------------------===// 143 144 /// \fn bool all(T x) 145 /// \brief Returns True if all components of the \a x parameter are non-zero; 146 /// otherwise, false. \param x The input value. 147 148 #ifdef __HLSL_ENABLE_16_BIT 149 _HLSL_AVAILABILITY(shadermodel, 6.2) 150 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 151 bool all(int16_t); 152 _HLSL_AVAILABILITY(shadermodel, 6.2) 153 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 154 bool all(int16_t2); 155 _HLSL_AVAILABILITY(shadermodel, 6.2) 156 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 157 bool all(int16_t3); 158 _HLSL_AVAILABILITY(shadermodel, 6.2) 159 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 160 bool all(int16_t4); 161 _HLSL_AVAILABILITY(shadermodel, 6.2) 162 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 163 bool all(uint16_t); 164 _HLSL_AVAILABILITY(shadermodel, 6.2) 165 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 166 bool all(uint16_t2); 167 _HLSL_AVAILABILITY(shadermodel, 6.2) 168 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 169 bool all(uint16_t3); 170 _HLSL_AVAILABILITY(shadermodel, 6.2) 171 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 172 bool all(uint16_t4); 173 #endif 174 175 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 176 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 177 bool all(half); 178 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 179 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 180 bool all(half2); 181 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 182 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 183 bool all(half3); 184 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 185 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 186 bool all(half4); 187 188 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 189 bool all(bool); 190 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 191 bool all(bool2); 192 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 193 bool all(bool3); 194 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 195 bool all(bool4); 196 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 197 198 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 199 bool all(int); 200 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 201 bool all(int2); 202 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 203 bool all(int3); 204 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 205 bool all(int4); 206 207 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 208 bool all(uint); 209 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 210 bool all(uint2); 211 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 212 bool all(uint3); 213 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 214 bool all(uint4); 215 216 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 217 bool all(float); 218 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 219 bool all(float2); 220 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 221 bool all(float3); 222 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 223 bool all(float4); 224 225 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 226 bool all(int64_t); 227 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 228 bool all(int64_t2); 229 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 230 bool all(int64_t3); 231 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 232 bool all(int64_t4); 233 234 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 235 bool all(uint64_t); 236 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 237 bool all(uint64_t2); 238 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 239 bool all(uint64_t3); 240 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 241 bool all(uint64_t4); 242 243 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 244 bool all(double); 245 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 246 bool all(double2); 247 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 248 bool all(double3); 249 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_all) 250 bool all(double4); 251 252 //===----------------------------------------------------------------------===// 253 // any builtins 254 //===----------------------------------------------------------------------===// 255 256 /// \fn bool any(T x) 257 /// \brief Returns True if any components of the \a x parameter are non-zero; 258 /// otherwise, false. \param x The input value. 259 260 #ifdef __HLSL_ENABLE_16_BIT 261 _HLSL_AVAILABILITY(shadermodel, 6.2) 262 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 263 bool any(int16_t); 264 _HLSL_AVAILABILITY(shadermodel, 6.2) 265 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 266 bool any(int16_t2); 267 _HLSL_AVAILABILITY(shadermodel, 6.2) 268 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 269 bool any(int16_t3); 270 _HLSL_AVAILABILITY(shadermodel, 6.2) 271 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 272 bool any(int16_t4); 273 _HLSL_AVAILABILITY(shadermodel, 6.2) 274 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 275 bool any(uint16_t); 276 _HLSL_AVAILABILITY(shadermodel, 6.2) 277 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 278 bool any(uint16_t2); 279 _HLSL_AVAILABILITY(shadermodel, 6.2) 280 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 281 bool any(uint16_t3); 282 _HLSL_AVAILABILITY(shadermodel, 6.2) 283 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 284 bool any(uint16_t4); 285 #endif 286 287 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 288 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 289 bool any(half); 290 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 291 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 292 bool any(half2); 293 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 294 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 295 bool any(half3); 296 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 297 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 298 bool any(half4); 299 300 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 301 bool any(bool); 302 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 303 bool any(bool2); 304 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 305 bool any(bool3); 306 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 307 bool any(bool4); 308 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 309 310 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 311 bool any(int); 312 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 313 bool any(int2); 314 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 315 bool any(int3); 316 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 317 bool any(int4); 318 319 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 320 bool any(uint); 321 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 322 bool any(uint2); 323 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 324 bool any(uint3); 325 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 326 bool any(uint4); 327 328 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 329 bool any(float); 330 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 331 bool any(float2); 332 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 333 bool any(float3); 334 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 335 bool any(float4); 336 337 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 338 bool any(int64_t); 339 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 340 bool any(int64_t2); 341 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 342 bool any(int64_t3); 343 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 344 bool any(int64_t4); 345 346 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 347 bool any(uint64_t); 348 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 349 bool any(uint64_t2); 350 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 351 bool any(uint64_t3); 352 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 353 bool any(uint64_t4); 354 355 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 356 bool any(double); 357 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 358 bool any(double2); 359 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 360 bool any(double3); 361 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_any) 362 bool any(double4); 363 364 //===----------------------------------------------------------------------===// 365 // asdouble builtins 366 //===----------------------------------------------------------------------===// 367 368 /// \fn double asdouble(uint LowBits, uint HighBits) 369 /// \brief Reinterprets a cast value (two 32-bit values) into a double. 370 /// \param LowBits The low 32-bit pattern of the input value. 371 /// \param HighBits The high 32-bit pattern of the input value. 372 373 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble) 374 double asdouble(uint, uint); 375 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble) 376 double2 asdouble(uint2, uint2); 377 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble) 378 double3 asdouble(uint3, uint3); 379 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_asdouble) 380 double4 asdouble(uint4, uint4); 381 382 //===----------------------------------------------------------------------===// 383 // asfloat builtins 384 //===----------------------------------------------------------------------===// 385 386 /// \fn float asfloat(T Val) 387 /// \brief Interprets the bit pattern of x as float point number. 388 /// \param Val The input value. 389 390 template <typename T, int N> 391 constexpr vector<float, N> asfloat(vector<T, N> V) { 392 return __detail::bit_cast<float, T, N>(V); 393 } 394 395 template <typename T> constexpr float asfloat(T F) { 396 return __detail::bit_cast<float, T>(F); 397 } 398 399 //===----------------------------------------------------------------------===// 400 // asint builtins 401 //===----------------------------------------------------------------------===// 402 403 /// \fn int asint(T Val) 404 /// \brief Interprets the bit pattern of x as an integer. 405 /// \param Val The input value. 406 407 template <typename T, int N> constexpr vector<int, N> asint(vector<T, N> V) { 408 return __detail::bit_cast<int, T, N>(V); 409 } 410 411 template <typename T> constexpr int asint(T F) { 412 return __detail::bit_cast<int, T>(F); 413 } 414 415 //===----------------------------------------------------------------------===// 416 // asin builtins 417 //===----------------------------------------------------------------------===// 418 419 /// \fn T asin(T Val) 420 /// \brief Returns the arcsine of the input value, \a Val. 421 /// \param Val The input value. 422 423 #ifdef __HLSL_ENABLE_16_BIT 424 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 425 half asin(half); 426 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 427 half2 asin(half2); 428 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 429 half3 asin(half3); 430 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 431 half4 asin(half4); 432 #endif 433 434 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 435 float asin(float); 436 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 437 float2 asin(float2); 438 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 439 float3 asin(float3); 440 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_asin) 441 float4 asin(float4); 442 443 //===----------------------------------------------------------------------===// 444 // asuint builtins 445 //===----------------------------------------------------------------------===// 446 447 /// \fn uint asuint(T Val) 448 /// \brief Interprets the bit pattern of x as an unsigned integer. 449 /// \param Val The input value. 450 451 template <typename T, int N> constexpr vector<uint, N> asuint(vector<T, N> V) { 452 return __detail::bit_cast<uint, T, N>(V); 453 } 454 455 template <typename T> constexpr uint asuint(T F) { 456 return __detail::bit_cast<uint, T>(F); 457 } 458 459 //===----------------------------------------------------------------------===// 460 // asuint splitdouble builtins 461 //===----------------------------------------------------------------------===// 462 463 /// \fn void asuint(double D, out uint lowbits, out int highbits) 464 /// \brief Split and interprets the lowbits and highbits of double D into uints. 465 /// \param D The input double. 466 /// \param lowbits The output lowbits of D. 467 /// \param highbits The output highbits of D. 468 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble) 469 void asuint(double, out uint, out uint); 470 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble) 471 void asuint(double2, out uint2, out uint2); 472 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble) 473 void asuint(double3, out uint3, out uint3); 474 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_splitdouble) 475 void asuint(double4, out uint4, out uint4); 476 477 //===----------------------------------------------------------------------===// 478 // atan builtins 479 //===----------------------------------------------------------------------===// 480 481 /// \fn T atan(T Val) 482 /// \brief Returns the arctangent of the input value, \a Val. 483 /// \param Val The input value. 484 485 #ifdef __HLSL_ENABLE_16_BIT 486 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 487 half atan(half); 488 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 489 half2 atan(half2); 490 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 491 half3 atan(half3); 492 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 493 half4 atan(half4); 494 #endif 495 496 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 497 float atan(float); 498 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 499 float2 atan(float2); 500 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 501 float3 atan(float3); 502 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan) 503 float4 atan(float4); 504 505 //===----------------------------------------------------------------------===// 506 // atan2 builtins 507 //===----------------------------------------------------------------------===// 508 509 /// \fn T atan2(T y, T x) 510 /// \brief Returns the arctangent of y/x, using the signs of the arguments to 511 /// determine the correct quadrant. 512 /// \param y The y-coordinate. 513 /// \param x The x-coordinate. 514 515 #ifdef __HLSL_ENABLE_16_BIT 516 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 517 half atan2(half y, half x); 518 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 519 half2 atan2(half2 y, half2 x); 520 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 521 half3 atan2(half3 y, half3 x); 522 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 523 half4 atan2(half4 y, half4 x); 524 #endif 525 526 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 527 float atan2(float y, float x); 528 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 529 float2 atan2(float2 y, float2 x); 530 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 531 float3 atan2(float3 y, float3 x); 532 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_atan2) 533 float4 atan2(float4 y, float4 x); 534 535 //===----------------------------------------------------------------------===// 536 // ceil builtins 537 //===----------------------------------------------------------------------===// 538 539 /// \fn T ceil(T Val) 540 /// \brief Returns the smallest integer value that is greater than or equal to 541 /// the input value, \a Val. 542 /// \param Val The input value. 543 544 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 545 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 546 half ceil(half); 547 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 548 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 549 half2 ceil(half2); 550 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 551 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 552 half3 ceil(half3); 553 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 554 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 555 half4 ceil(half4); 556 557 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 558 float ceil(float); 559 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 560 float2 ceil(float2); 561 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 562 float3 ceil(float3); 563 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) 564 float4 ceil(float4); 565 566 //===----------------------------------------------------------------------===// 567 // clamp builtins 568 //===----------------------------------------------------------------------===// 569 570 /// \fn T clamp(T X, T Min, T Max) 571 /// \brief Clamps the specified value \a X to the specified 572 /// minimum ( \a Min) and maximum ( \a Max) range. 573 /// \param X A value to clamp. 574 /// \param Min The specified minimum range. 575 /// \param Max The specified maximum range. 576 /// 577 /// Returns The clamped value for the \a X parameter. 578 /// For values of -INF or INF, clamp will behave as expected. 579 /// However for values of NaN, the results are undefined. 580 581 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 582 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 583 half clamp(half, half, half); 584 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 585 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 586 half2 clamp(half2, half2, half2); 587 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 588 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 589 half3 clamp(half3, half3, half3); 590 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 591 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 592 half4 clamp(half4, half4, half4); 593 594 #ifdef __HLSL_ENABLE_16_BIT 595 _HLSL_AVAILABILITY(shadermodel, 6.2) 596 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 597 int16_t clamp(int16_t, int16_t, int16_t); 598 _HLSL_AVAILABILITY(shadermodel, 6.2) 599 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 600 int16_t2 clamp(int16_t2, int16_t2, int16_t2); 601 _HLSL_AVAILABILITY(shadermodel, 6.2) 602 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 603 int16_t3 clamp(int16_t3, int16_t3, int16_t3); 604 _HLSL_AVAILABILITY(shadermodel, 6.2) 605 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 606 int16_t4 clamp(int16_t4, int16_t4, int16_t4); 607 608 _HLSL_AVAILABILITY(shadermodel, 6.2) 609 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 610 uint16_t clamp(uint16_t, uint16_t, uint16_t); 611 _HLSL_AVAILABILITY(shadermodel, 6.2) 612 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 613 uint16_t2 clamp(uint16_t2, uint16_t2, uint16_t2); 614 _HLSL_AVAILABILITY(shadermodel, 6.2) 615 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 616 uint16_t3 clamp(uint16_t3, uint16_t3, uint16_t3); 617 _HLSL_AVAILABILITY(shadermodel, 6.2) 618 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 619 uint16_t4 clamp(uint16_t4, uint16_t4, uint16_t4); 620 #endif 621 622 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 623 int clamp(int, int, int); 624 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 625 int2 clamp(int2, int2, int2); 626 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 627 int3 clamp(int3, int3, int3); 628 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 629 int4 clamp(int4, int4, int4); 630 631 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 632 uint clamp(uint, uint, uint); 633 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 634 uint2 clamp(uint2, uint2, uint2); 635 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 636 uint3 clamp(uint3, uint3, uint3); 637 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 638 uint4 clamp(uint4, uint4, uint4); 639 640 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 641 int64_t clamp(int64_t, int64_t, int64_t); 642 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 643 int64_t2 clamp(int64_t2, int64_t2, int64_t2); 644 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 645 int64_t3 clamp(int64_t3, int64_t3, int64_t3); 646 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 647 int64_t4 clamp(int64_t4, int64_t4, int64_t4); 648 649 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 650 uint64_t clamp(uint64_t, uint64_t, uint64_t); 651 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 652 uint64_t2 clamp(uint64_t2, uint64_t2, uint64_t2); 653 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 654 uint64_t3 clamp(uint64_t3, uint64_t3, uint64_t3); 655 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 656 uint64_t4 clamp(uint64_t4, uint64_t4, uint64_t4); 657 658 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 659 float clamp(float, float, float); 660 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 661 float2 clamp(float2, float2, float2); 662 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 663 float3 clamp(float3, float3, float3); 664 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 665 float4 clamp(float4, float4, float4); 666 667 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 668 double clamp(double, double, double); 669 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 670 double2 clamp(double2, double2, double2); 671 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 672 double3 clamp(double3, double3, double3); 673 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) 674 double4 clamp(double4, double4, double4); 675 676 //===----------------------------------------------------------------------===// 677 // clip builtins 678 //===----------------------------------------------------------------------===// 679 680 /// \fn void clip(T Val) 681 /// \brief Discards the current pixel if the specified value is less than zero. 682 /// \param Val The input value. 683 684 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip) 685 void clip(float); 686 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip) 687 void clip(float2); 688 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip) 689 void clip(float3); 690 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clip) 691 void clip(float4); 692 693 //===----------------------------------------------------------------------===// 694 // cos builtins 695 //===----------------------------------------------------------------------===// 696 697 /// \fn T cos(T Val) 698 /// \brief Returns the cosine of the input value, \a Val. 699 /// \param Val The input value. 700 701 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 702 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 703 half cos(half); 704 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 705 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 706 half2 cos(half2); 707 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 708 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 709 half3 cos(half3); 710 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 711 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 712 half4 cos(half4); 713 714 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 715 float cos(float); 716 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 717 float2 cos(float2); 718 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 719 float3 cos(float3); 720 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) 721 float4 cos(float4); 722 723 //===----------------------------------------------------------------------===// 724 // cosh builtins 725 //===----------------------------------------------------------------------===// 726 727 /// \fn T cosh(T Val) 728 /// \brief Returns the hyperbolic cosine of the input value, \a Val. 729 /// \param Val The input value. 730 731 #ifdef __HLSL_ENABLE_16_BIT 732 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 733 half cosh(half); 734 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 735 half2 cosh(half2); 736 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 737 half3 cosh(half3); 738 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 739 half4 cosh(half4); 740 #endif 741 742 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 743 float cosh(float); 744 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 745 float2 cosh(float2); 746 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 747 float3 cosh(float3); 748 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cosh) 749 float4 cosh(float4); 750 751 //===----------------------------------------------------------------------===// 752 // count bits builtins 753 //===----------------------------------------------------------------------===// 754 755 /// \fn T countbits(T Val) 756 /// \brief Return the number of bits (per component) set in the input integer. 757 /// \param Val The input value. 758 759 #ifdef __HLSL_ENABLE_16_BIT 760 _HLSL_AVAILABILITY(shadermodel, 6.2) 761 const inline uint countbits(int16_t x) { 762 return __builtin_elementwise_popcount(x); 763 } 764 _HLSL_AVAILABILITY(shadermodel, 6.2) 765 const inline uint2 countbits(int16_t2 x) { 766 return __builtin_elementwise_popcount(x); 767 } 768 _HLSL_AVAILABILITY(shadermodel, 6.2) 769 const inline uint3 countbits(int16_t3 x) { 770 return __builtin_elementwise_popcount(x); 771 } 772 _HLSL_AVAILABILITY(shadermodel, 6.2) 773 const inline uint4 countbits(int16_t4 x) { 774 return __builtin_elementwise_popcount(x); 775 } 776 _HLSL_AVAILABILITY(shadermodel, 6.2) 777 const inline uint countbits(uint16_t x) { 778 return __builtin_elementwise_popcount(x); 779 } 780 _HLSL_AVAILABILITY(shadermodel, 6.2) 781 const inline uint2 countbits(uint16_t2 x) { 782 return __builtin_elementwise_popcount(x); 783 } 784 _HLSL_AVAILABILITY(shadermodel, 6.2) 785 const inline uint3 countbits(uint16_t3 x) { 786 return __builtin_elementwise_popcount(x); 787 } 788 _HLSL_AVAILABILITY(shadermodel, 6.2) 789 const inline uint4 countbits(uint16_t4 x) { 790 return __builtin_elementwise_popcount(x); 791 } 792 #endif 793 794 const inline uint countbits(int x) { return __builtin_elementwise_popcount(x); } 795 const inline uint2 countbits(int2 x) { 796 return __builtin_elementwise_popcount(x); 797 } 798 const inline uint3 countbits(int3 x) { 799 return __builtin_elementwise_popcount(x); 800 } 801 const inline uint4 countbits(int4 x) { 802 return __builtin_elementwise_popcount(x); 803 } 804 805 const inline uint countbits(uint x) { 806 return __builtin_elementwise_popcount(x); 807 } 808 const inline uint2 countbits(uint2 x) { 809 return __builtin_elementwise_popcount(x); 810 } 811 const inline uint3 countbits(uint3 x) { 812 return __builtin_elementwise_popcount(x); 813 } 814 const inline uint4 countbits(uint4 x) { 815 return __builtin_elementwise_popcount(x); 816 } 817 818 const inline uint countbits(int64_t x) { 819 return __builtin_elementwise_popcount(x); 820 } 821 const inline uint2 countbits(int64_t2 x) { 822 return __builtin_elementwise_popcount(x); 823 } 824 const inline uint3 countbits(int64_t3 x) { 825 return __builtin_elementwise_popcount(x); 826 } 827 const inline uint4 countbits(int64_t4 x) { 828 return __builtin_elementwise_popcount(x); 829 } 830 831 const inline uint countbits(uint64_t x) { 832 return __builtin_elementwise_popcount(x); 833 } 834 const inline uint2 countbits(uint64_t2 x) { 835 return __builtin_elementwise_popcount(x); 836 } 837 const inline uint3 countbits(uint64_t3 x) { 838 return __builtin_elementwise_popcount(x); 839 } 840 const inline uint4 countbits(uint64_t4 x) { 841 return __builtin_elementwise_popcount(x); 842 } 843 844 //===----------------------------------------------------------------------===// 845 // degrees builtins 846 //===----------------------------------------------------------------------===// 847 848 /// \fn T degrees(T x) 849 /// \brief Converts the specified value from radians to degrees. 850 /// \param x The specified input value. 851 852 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 853 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 854 half degrees(half); 855 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 856 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 857 half2 degrees(half2); 858 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 859 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 860 half3 degrees(half3); 861 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 862 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 863 half4 degrees(half4); 864 865 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 866 float degrees(float); 867 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 868 float2 degrees(float2); 869 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 870 float3 degrees(float3); 871 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_degrees) 872 float4 degrees(float4); 873 874 //===----------------------------------------------------------------------===// 875 // distance builtins 876 //===----------------------------------------------------------------------===// 877 878 /// \fn K distance(T X, T Y) 879 /// \brief Returns a distance scalar between \a X and \a Y. 880 /// \param X The X input value. 881 /// \param Y The Y input value. 882 883 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 884 const inline half distance(half X, half Y) { 885 return __detail::distance_impl(X, Y); 886 } 887 888 const inline float distance(float X, float Y) { 889 return __detail::distance_impl(X, Y); 890 } 891 892 template <int N> 893 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 894 const inline half distance(vector<half, N> X, vector<half, N> Y) { 895 return __detail::distance_vec_impl(X, Y); 896 } 897 898 template <int N> 899 const inline float distance(vector<float, N> X, vector<float, N> Y) { 900 return __detail::distance_vec_impl(X, Y); 901 } 902 903 //===----------------------------------------------------------------------===// 904 // dot product builtins 905 //===----------------------------------------------------------------------===// 906 907 /// \fn K dot(T X, T Y) 908 /// \brief Return the dot product (a scalar value) of \a X and \a Y. 909 /// \param X The X input value. 910 /// \param Y The Y input value. 911 912 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 913 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 914 half dot(half, half); 915 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 916 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 917 half dot(half2, half2); 918 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 919 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 920 half dot(half3, half3); 921 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 922 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 923 half dot(half4, half4); 924 925 #ifdef __HLSL_ENABLE_16_BIT 926 _HLSL_AVAILABILITY(shadermodel, 6.2) 927 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 928 int16_t dot(int16_t, int16_t); 929 _HLSL_AVAILABILITY(shadermodel, 6.2) 930 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 931 int16_t dot(int16_t2, int16_t2); 932 _HLSL_AVAILABILITY(shadermodel, 6.2) 933 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 934 int16_t dot(int16_t3, int16_t3); 935 _HLSL_AVAILABILITY(shadermodel, 6.2) 936 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 937 int16_t dot(int16_t4, int16_t4); 938 939 _HLSL_AVAILABILITY(shadermodel, 6.2) 940 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 941 uint16_t dot(uint16_t, uint16_t); 942 _HLSL_AVAILABILITY(shadermodel, 6.2) 943 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 944 uint16_t dot(uint16_t2, uint16_t2); 945 _HLSL_AVAILABILITY(shadermodel, 6.2) 946 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 947 uint16_t dot(uint16_t3, uint16_t3); 948 _HLSL_AVAILABILITY(shadermodel, 6.2) 949 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 950 uint16_t dot(uint16_t4, uint16_t4); 951 #endif 952 953 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 954 float dot(float, float); 955 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 956 float dot(float2, float2); 957 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 958 float dot(float3, float3); 959 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 960 float dot(float4, float4); 961 962 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 963 double dot(double, double); 964 965 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 966 int dot(int, int); 967 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 968 int dot(int2, int2); 969 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 970 int dot(int3, int3); 971 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 972 int dot(int4, int4); 973 974 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 975 uint dot(uint, uint); 976 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 977 uint dot(uint2, uint2); 978 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 979 uint dot(uint3, uint3); 980 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 981 uint dot(uint4, uint4); 982 983 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 984 int64_t dot(int64_t, int64_t); 985 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 986 int64_t dot(int64_t2, int64_t2); 987 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 988 int64_t dot(int64_t3, int64_t3); 989 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 990 int64_t dot(int64_t4, int64_t4); 991 992 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 993 uint64_t dot(uint64_t, uint64_t); 994 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 995 uint64_t dot(uint64_t2, uint64_t2); 996 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 997 uint64_t dot(uint64_t3, uint64_t3); 998 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) 999 uint64_t dot(uint64_t4, uint64_t4); 1000 1001 //===----------------------------------------------------------------------===// 1002 // dot4add builtins 1003 //===----------------------------------------------------------------------===// 1004 1005 /// \fn int dot4add_i8packed(uint A, uint B, int C) 1006 1007 _HLSL_AVAILABILITY(shadermodel, 6.4) 1008 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_i8packed) 1009 int dot4add_i8packed(uint, uint, int); 1010 1011 /// \fn uint dot4add_u8packed(uint A, uint B, uint C) 1012 1013 _HLSL_AVAILABILITY(shadermodel, 6.4) 1014 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot4add_u8packed) 1015 uint dot4add_u8packed(uint, uint, uint); 1016 1017 //===----------------------------------------------------------------------===// 1018 // exp builtins 1019 //===----------------------------------------------------------------------===// 1020 1021 /// \fn T exp(T x) 1022 /// \brief Returns the base-e exponential, or \a e**x, of the specified value. 1023 /// \param x The specified input value. 1024 /// 1025 /// The return value is the base-e exponential of the \a x parameter. 1026 1027 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1028 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1029 half exp(half); 1030 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1031 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1032 half2 exp(half2); 1033 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1034 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1035 half3 exp(half3); 1036 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1037 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1038 half4 exp(half4); 1039 1040 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1041 float exp(float); 1042 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1043 float2 exp(float2); 1044 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1045 float3 exp(float3); 1046 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) 1047 float4 exp(float4); 1048 1049 //===----------------------------------------------------------------------===// 1050 // exp2 builtins 1051 //===----------------------------------------------------------------------===// 1052 1053 /// \fn T exp2(T x) 1054 /// \brief Returns the base 2 exponential, or \a 2**x, of the specified value. 1055 /// \param x The specified input value. 1056 /// 1057 /// The base 2 exponential of the \a x parameter. 1058 1059 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1060 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1061 half exp2(half); 1062 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1063 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1064 half2 exp2(half2); 1065 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1066 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1067 half3 exp2(half3); 1068 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1069 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1070 half4 exp2(half4); 1071 1072 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1073 float exp2(float); 1074 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1075 float2 exp2(float2); 1076 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1077 float3 exp2(float3); 1078 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) 1079 float4 exp2(float4); 1080 1081 //===----------------------------------------------------------------------===// 1082 // firstbithigh builtins 1083 //===----------------------------------------------------------------------===// 1084 1085 /// \fn T firstbithigh(T Val) 1086 /// \brief Returns the location of the first set bit starting from the highest 1087 /// order bit and working downward, per component. 1088 /// \param Val the input value. 1089 1090 #ifdef __HLSL_ENABLE_16_BIT 1091 _HLSL_AVAILABILITY(shadermodel, 6.2) 1092 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1093 uint firstbithigh(int16_t); 1094 _HLSL_AVAILABILITY(shadermodel, 6.2) 1095 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1096 uint2 firstbithigh(int16_t2); 1097 _HLSL_AVAILABILITY(shadermodel, 6.2) 1098 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1099 uint3 firstbithigh(int16_t3); 1100 _HLSL_AVAILABILITY(shadermodel, 6.2) 1101 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1102 uint4 firstbithigh(int16_t4); 1103 _HLSL_AVAILABILITY(shadermodel, 6.2) 1104 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1105 uint firstbithigh(uint16_t); 1106 _HLSL_AVAILABILITY(shadermodel, 6.2) 1107 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1108 uint2 firstbithigh(uint16_t2); 1109 _HLSL_AVAILABILITY(shadermodel, 6.2) 1110 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1111 uint3 firstbithigh(uint16_t3); 1112 _HLSL_AVAILABILITY(shadermodel, 6.2) 1113 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1114 uint4 firstbithigh(uint16_t4); 1115 #endif 1116 1117 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1118 uint firstbithigh(int); 1119 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1120 uint2 firstbithigh(int2); 1121 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1122 uint3 firstbithigh(int3); 1123 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1124 uint4 firstbithigh(int4); 1125 1126 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1127 uint firstbithigh(uint); 1128 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1129 uint2 firstbithigh(uint2); 1130 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1131 uint3 firstbithigh(uint3); 1132 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1133 uint4 firstbithigh(uint4); 1134 1135 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1136 uint firstbithigh(int64_t); 1137 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1138 uint2 firstbithigh(int64_t2); 1139 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1140 uint3 firstbithigh(int64_t3); 1141 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1142 uint4 firstbithigh(int64_t4); 1143 1144 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1145 uint firstbithigh(uint64_t); 1146 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1147 uint2 firstbithigh(uint64_t2); 1148 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1149 uint3 firstbithigh(uint64_t3); 1150 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbithigh) 1151 uint4 firstbithigh(uint64_t4); 1152 1153 //===----------------------------------------------------------------------===// 1154 // firstbitlow builtins 1155 //===----------------------------------------------------------------------===// 1156 1157 /// \fn T firstbitlow(T Val) 1158 /// \brief Returns the location of the first set bit starting from the lowest 1159 /// order bit and working upward, per component. 1160 /// \param Val the input value. 1161 1162 #ifdef __HLSL_ENABLE_16_BIT 1163 _HLSL_AVAILABILITY(shadermodel, 6.2) 1164 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1165 uint firstbitlow(int16_t); 1166 _HLSL_AVAILABILITY(shadermodel, 6.2) 1167 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1168 uint2 firstbitlow(int16_t2); 1169 _HLSL_AVAILABILITY(shadermodel, 6.2) 1170 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1171 uint3 firstbitlow(int16_t3); 1172 _HLSL_AVAILABILITY(shadermodel, 6.2) 1173 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1174 uint4 firstbitlow(int16_t4); 1175 _HLSL_AVAILABILITY(shadermodel, 6.2) 1176 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1177 uint firstbitlow(uint16_t); 1178 _HLSL_AVAILABILITY(shadermodel, 6.2) 1179 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1180 uint2 firstbitlow(uint16_t2); 1181 _HLSL_AVAILABILITY(shadermodel, 6.2) 1182 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1183 uint3 firstbitlow(uint16_t3); 1184 _HLSL_AVAILABILITY(shadermodel, 6.2) 1185 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1186 uint4 firstbitlow(uint16_t4); 1187 #endif 1188 1189 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1190 uint firstbitlow(int); 1191 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1192 uint2 firstbitlow(int2); 1193 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1194 uint3 firstbitlow(int3); 1195 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1196 uint4 firstbitlow(int4); 1197 1198 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1199 uint firstbitlow(uint); 1200 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1201 uint2 firstbitlow(uint2); 1202 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1203 uint3 firstbitlow(uint3); 1204 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1205 uint4 firstbitlow(uint4); 1206 1207 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1208 uint firstbitlow(int64_t); 1209 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1210 uint2 firstbitlow(int64_t2); 1211 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1212 uint3 firstbitlow(int64_t3); 1213 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1214 uint4 firstbitlow(int64_t4); 1215 1216 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1217 uint firstbitlow(uint64_t); 1218 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1219 uint2 firstbitlow(uint64_t2); 1220 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1221 uint3 firstbitlow(uint64_t3); 1222 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_firstbitlow) 1223 uint4 firstbitlow(uint64_t4); 1224 1225 //===----------------------------------------------------------------------===// 1226 // floor builtins 1227 //===----------------------------------------------------------------------===// 1228 1229 /// \fn T floor(T Val) 1230 /// \brief Returns the largest integer that is less than or equal to the input 1231 /// value, \a Val. 1232 /// \param Val The input value. 1233 1234 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1235 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1236 half floor(half); 1237 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1238 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1239 half2 floor(half2); 1240 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1241 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1242 half3 floor(half3); 1243 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1244 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1245 half4 floor(half4); 1246 1247 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1248 float floor(float); 1249 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1250 float2 floor(float2); 1251 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1252 float3 floor(float3); 1253 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) 1254 float4 floor(float4); 1255 1256 //===----------------------------------------------------------------------===// 1257 // fmod builtins 1258 //===----------------------------------------------------------------------===// 1259 1260 /// \fn T fmod(T x, T y) 1261 /// \brief Returns the linear interpolation of x to y. 1262 /// \param x [in] The dividend. 1263 /// \param y [in] The divisor. 1264 /// 1265 /// Return the floating-point remainder of the x parameter divided by the y 1266 /// parameter. 1267 1268 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1269 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1270 half fmod(half, half); 1271 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1272 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1273 half2 fmod(half2, half2); 1274 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1275 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1276 half3 fmod(half3, half3); 1277 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1278 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1279 half4 fmod(half4, half4); 1280 1281 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1282 float fmod(float, float); 1283 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1284 float2 fmod(float2, float2); 1285 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1286 float3 fmod(float3, float3); 1287 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_fmod) 1288 float4 fmod(float4, float4); 1289 1290 //===----------------------------------------------------------------------===// 1291 // frac builtins 1292 //===----------------------------------------------------------------------===// 1293 1294 /// \fn T frac(T x) 1295 /// \brief Returns the fractional (or decimal) part of x. \a x parameter. 1296 /// \param x The specified input value. 1297 /// 1298 /// If \a the return value is greater than or equal to 0 and less than 1. 1299 1300 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1301 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1302 half frac(half); 1303 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1304 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1305 half2 frac(half2); 1306 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1307 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1308 half3 frac(half3); 1309 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1310 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1311 half4 frac(half4); 1312 1313 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1314 float frac(float); 1315 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1316 float2 frac(float2); 1317 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1318 float3 frac(float3); 1319 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) 1320 float4 frac(float4); 1321 1322 //===----------------------------------------------------------------------===// 1323 // isinf builtins 1324 //===----------------------------------------------------------------------===// 1325 1326 /// \fn T isinf(T x) 1327 /// \brief Determines if the specified value \a x is infinite. 1328 /// \param x The specified input value. 1329 /// 1330 /// Returns a value of the same size as the input, with a value set 1331 /// to True if the x parameter is +INF or -INF. Otherwise, False. 1332 1333 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1334 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1335 bool isinf(half); 1336 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1337 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1338 bool2 isinf(half2); 1339 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1340 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1341 bool3 isinf(half3); 1342 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1343 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1344 bool4 isinf(half4); 1345 1346 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1347 bool isinf(float); 1348 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1349 bool2 isinf(float2); 1350 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1351 bool3 isinf(float3); 1352 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) 1353 bool4 isinf(float4); 1354 1355 //===----------------------------------------------------------------------===// 1356 // lerp builtins 1357 //===----------------------------------------------------------------------===// 1358 1359 /// \fn T lerp(T x, T y, T s) 1360 /// \brief Returns the linear interpolation of x to y by s. 1361 /// \param x [in] The first-floating point value. 1362 /// \param y [in] The second-floating point value. 1363 /// \param s [in] A value that linearly interpolates between the x parameter and 1364 /// the y parameter. 1365 /// 1366 /// Linear interpolation is based on the following formula: x*(1-s) + y*s which 1367 /// can equivalently be written as x + s(y-x). 1368 1369 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1370 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1371 half lerp(half, half, half); 1372 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1373 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1374 half2 lerp(half2, half2, half2); 1375 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1376 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1377 half3 lerp(half3, half3, half3); 1378 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1379 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1380 half4 lerp(half4, half4, half4); 1381 1382 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1383 float lerp(float, float, float); 1384 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1385 float2 lerp(float2, float2, float2); 1386 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1387 float3 lerp(float3, float3, float3); 1388 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) 1389 float4 lerp(float4, float4, float4); 1390 1391 //===----------------------------------------------------------------------===// 1392 // length builtins 1393 //===----------------------------------------------------------------------===// 1394 1395 /// \fn T length(T x) 1396 /// \brief Returns the length of the specified floating-point vector. 1397 /// \param x [in] The vector of floats, or a scalar float. 1398 /// 1399 /// Length is based on the following formula: sqrt(x[0]^2 + x[1]^2 + ...). 1400 1401 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1402 const inline half length(half X) { return __detail::length_impl(X); } 1403 const inline float length(float X) { return __detail::length_impl(X); } 1404 1405 template <int N> 1406 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1407 const inline half length(vector<half, N> X) { 1408 return __detail::length_vec_impl(X); 1409 } 1410 1411 template <int N> const inline float length(vector<float, N> X) { 1412 return __detail::length_vec_impl(X); 1413 } 1414 1415 //===----------------------------------------------------------------------===// 1416 // log builtins 1417 //===----------------------------------------------------------------------===// 1418 1419 /// \fn T log(T Val) 1420 /// \brief The base-e logarithm of the input value, \a Val parameter. 1421 /// \param Val The input value. 1422 /// 1423 /// If \a Val is negative, this result is undefined. If \a Val is 0, this 1424 /// function returns negative infinity. 1425 1426 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1427 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1428 half log(half); 1429 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1430 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1431 half2 log(half2); 1432 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1433 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1434 half3 log(half3); 1435 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1436 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1437 half4 log(half4); 1438 1439 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1440 float log(float); 1441 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1442 float2 log(float2); 1443 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1444 float3 log(float3); 1445 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) 1446 float4 log(float4); 1447 1448 //===----------------------------------------------------------------------===// 1449 // log10 builtins 1450 //===----------------------------------------------------------------------===// 1451 1452 /// \fn T log10(T Val) 1453 /// \brief The base-10 logarithm of the input value, \a Val parameter. 1454 /// \param Val The input value. 1455 /// 1456 /// If \a Val is negative, this result is undefined. If \a Val is 0, this 1457 /// function returns negative infinity. 1458 1459 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1460 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1461 half log10(half); 1462 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1463 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1464 half2 log10(half2); 1465 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1466 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1467 half3 log10(half3); 1468 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1469 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1470 half4 log10(half4); 1471 1472 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1473 float log10(float); 1474 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1475 float2 log10(float2); 1476 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1477 float3 log10(float3); 1478 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) 1479 float4 log10(float4); 1480 1481 //===----------------------------------------------------------------------===// 1482 // log2 builtins 1483 //===----------------------------------------------------------------------===// 1484 1485 /// \fn T log2(T Val) 1486 /// \brief The base-2 logarithm of the input value, \a Val parameter. 1487 /// \param Val The input value. 1488 /// 1489 /// If \a Val is negative, this result is undefined. If \a Val is 0, this 1490 /// function returns negative infinity. 1491 1492 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1493 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1494 half log2(half); 1495 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1496 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1497 half2 log2(half2); 1498 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1499 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1500 half3 log2(half3); 1501 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1502 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1503 half4 log2(half4); 1504 1505 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1506 float log2(float); 1507 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1508 float2 log2(float2); 1509 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1510 float3 log2(float3); 1511 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) 1512 float4 log2(float4); 1513 1514 //===----------------------------------------------------------------------===// 1515 // mad builtins 1516 //===----------------------------------------------------------------------===// 1517 1518 /// \fn T mad(T M, T A, T B) 1519 /// \brief The result of \a M * \a A + \a B. 1520 /// \param M The multiplication value. 1521 /// \param A The first addition value. 1522 /// \param B The second addition value. 1523 1524 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1525 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1526 half mad(half, half, half); 1527 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1528 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1529 half2 mad(half2, half2, half2); 1530 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1531 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1532 half3 mad(half3, half3, half3); 1533 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1534 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1535 half4 mad(half4, half4, half4); 1536 1537 #ifdef __HLSL_ENABLE_16_BIT 1538 _HLSL_AVAILABILITY(shadermodel, 6.2) 1539 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1540 int16_t mad(int16_t, int16_t, int16_t); 1541 _HLSL_AVAILABILITY(shadermodel, 6.2) 1542 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1543 int16_t2 mad(int16_t2, int16_t2, int16_t2); 1544 _HLSL_AVAILABILITY(shadermodel, 6.2) 1545 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1546 int16_t3 mad(int16_t3, int16_t3, int16_t3); 1547 _HLSL_AVAILABILITY(shadermodel, 6.2) 1548 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1549 int16_t4 mad(int16_t4, int16_t4, int16_t4); 1550 1551 _HLSL_AVAILABILITY(shadermodel, 6.2) 1552 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1553 uint16_t mad(uint16_t, uint16_t, uint16_t); 1554 _HLSL_AVAILABILITY(shadermodel, 6.2) 1555 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1556 uint16_t2 mad(uint16_t2, uint16_t2, uint16_t2); 1557 _HLSL_AVAILABILITY(shadermodel, 6.2) 1558 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1559 uint16_t3 mad(uint16_t3, uint16_t3, uint16_t3); 1560 _HLSL_AVAILABILITY(shadermodel, 6.2) 1561 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1562 uint16_t4 mad(uint16_t4, uint16_t4, uint16_t4); 1563 #endif 1564 1565 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1566 int mad(int, int, int); 1567 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1568 int2 mad(int2, int2, int2); 1569 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1570 int3 mad(int3, int3, int3); 1571 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1572 int4 mad(int4, int4, int4); 1573 1574 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1575 uint mad(uint, uint, uint); 1576 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1577 uint2 mad(uint2, uint2, uint2); 1578 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1579 uint3 mad(uint3, uint3, uint3); 1580 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1581 uint4 mad(uint4, uint4, uint4); 1582 1583 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1584 int64_t mad(int64_t, int64_t, int64_t); 1585 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1586 int64_t2 mad(int64_t2, int64_t2, int64_t2); 1587 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1588 int64_t3 mad(int64_t3, int64_t3, int64_t3); 1589 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1590 int64_t4 mad(int64_t4, int64_t4, int64_t4); 1591 1592 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1593 uint64_t mad(uint64_t, uint64_t, uint64_t); 1594 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1595 uint64_t2 mad(uint64_t2, uint64_t2, uint64_t2); 1596 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1597 uint64_t3 mad(uint64_t3, uint64_t3, uint64_t3); 1598 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1599 uint64_t4 mad(uint64_t4, uint64_t4, uint64_t4); 1600 1601 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1602 float mad(float, float, float); 1603 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1604 float2 mad(float2, float2, float2); 1605 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1606 float3 mad(float3, float3, float3); 1607 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1608 float4 mad(float4, float4, float4); 1609 1610 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1611 double mad(double, double, double); 1612 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1613 double2 mad(double2, double2, double2); 1614 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1615 double3 mad(double3, double3, double3); 1616 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) 1617 double4 mad(double4, double4, double4); 1618 1619 //===----------------------------------------------------------------------===// 1620 // max builtins 1621 //===----------------------------------------------------------------------===// 1622 1623 /// \fn T max(T X, T Y) 1624 /// \brief Return the greater of \a X and \a Y. 1625 /// \param X The X input value. 1626 /// \param Y The Y input value. 1627 1628 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1629 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1630 half max(half, half); 1631 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1632 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1633 half2 max(half2, half2); 1634 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1635 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1636 half3 max(half3, half3); 1637 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1638 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1639 half4 max(half4, half4); 1640 1641 #ifdef __HLSL_ENABLE_16_BIT 1642 _HLSL_AVAILABILITY(shadermodel, 6.2) 1643 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1644 int16_t max(int16_t, int16_t); 1645 _HLSL_AVAILABILITY(shadermodel, 6.2) 1646 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1647 int16_t2 max(int16_t2, int16_t2); 1648 _HLSL_AVAILABILITY(shadermodel, 6.2) 1649 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1650 int16_t3 max(int16_t3, int16_t3); 1651 _HLSL_AVAILABILITY(shadermodel, 6.2) 1652 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1653 int16_t4 max(int16_t4, int16_t4); 1654 1655 _HLSL_AVAILABILITY(shadermodel, 6.2) 1656 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1657 uint16_t max(uint16_t, uint16_t); 1658 _HLSL_AVAILABILITY(shadermodel, 6.2) 1659 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1660 uint16_t2 max(uint16_t2, uint16_t2); 1661 _HLSL_AVAILABILITY(shadermodel, 6.2) 1662 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1663 uint16_t3 max(uint16_t3, uint16_t3); 1664 _HLSL_AVAILABILITY(shadermodel, 6.2) 1665 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1666 uint16_t4 max(uint16_t4, uint16_t4); 1667 #endif 1668 1669 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1670 int max(int, int); 1671 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1672 int2 max(int2, int2); 1673 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1674 int3 max(int3, int3); 1675 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1676 int4 max(int4, int4); 1677 1678 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1679 uint max(uint, uint); 1680 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1681 uint2 max(uint2, uint2); 1682 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1683 uint3 max(uint3, uint3); 1684 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1685 uint4 max(uint4, uint4); 1686 1687 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1688 int64_t max(int64_t, int64_t); 1689 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1690 int64_t2 max(int64_t2, int64_t2); 1691 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1692 int64_t3 max(int64_t3, int64_t3); 1693 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1694 int64_t4 max(int64_t4, int64_t4); 1695 1696 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1697 uint64_t max(uint64_t, uint64_t); 1698 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1699 uint64_t2 max(uint64_t2, uint64_t2); 1700 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1701 uint64_t3 max(uint64_t3, uint64_t3); 1702 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1703 uint64_t4 max(uint64_t4, uint64_t4); 1704 1705 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1706 float max(float, float); 1707 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1708 float2 max(float2, float2); 1709 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1710 float3 max(float3, float3); 1711 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1712 float4 max(float4, float4); 1713 1714 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1715 double max(double, double); 1716 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1717 double2 max(double2, double2); 1718 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1719 double3 max(double3, double3); 1720 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) 1721 double4 max(double4, double4); 1722 1723 //===----------------------------------------------------------------------===// 1724 // min builtins 1725 //===----------------------------------------------------------------------===// 1726 1727 /// \fn T min(T X, T Y) 1728 /// \brief Return the lesser of \a X and \a Y. 1729 /// \param X The X input value. 1730 /// \param Y The Y input value. 1731 1732 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1733 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1734 half min(half, half); 1735 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1736 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1737 half2 min(half2, half2); 1738 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1739 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1740 half3 min(half3, half3); 1741 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1742 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1743 half4 min(half4, half4); 1744 1745 #ifdef __HLSL_ENABLE_16_BIT 1746 _HLSL_AVAILABILITY(shadermodel, 6.2) 1747 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1748 int16_t min(int16_t, int16_t); 1749 _HLSL_AVAILABILITY(shadermodel, 6.2) 1750 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1751 int16_t2 min(int16_t2, int16_t2); 1752 _HLSL_AVAILABILITY(shadermodel, 6.2) 1753 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1754 int16_t3 min(int16_t3, int16_t3); 1755 _HLSL_AVAILABILITY(shadermodel, 6.2) 1756 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1757 int16_t4 min(int16_t4, int16_t4); 1758 1759 _HLSL_AVAILABILITY(shadermodel, 6.2) 1760 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1761 uint16_t min(uint16_t, uint16_t); 1762 _HLSL_AVAILABILITY(shadermodel, 6.2) 1763 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1764 uint16_t2 min(uint16_t2, uint16_t2); 1765 _HLSL_AVAILABILITY(shadermodel, 6.2) 1766 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1767 uint16_t3 min(uint16_t3, uint16_t3); 1768 _HLSL_AVAILABILITY(shadermodel, 6.2) 1769 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1770 uint16_t4 min(uint16_t4, uint16_t4); 1771 #endif 1772 1773 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1774 int min(int, int); 1775 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1776 int2 min(int2, int2); 1777 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1778 int3 min(int3, int3); 1779 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1780 int4 min(int4, int4); 1781 1782 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1783 uint min(uint, uint); 1784 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1785 uint2 min(uint2, uint2); 1786 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1787 uint3 min(uint3, uint3); 1788 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1789 uint4 min(uint4, uint4); 1790 1791 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1792 float min(float, float); 1793 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1794 float2 min(float2, float2); 1795 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1796 float3 min(float3, float3); 1797 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1798 float4 min(float4, float4); 1799 1800 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1801 int64_t min(int64_t, int64_t); 1802 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1803 int64_t2 min(int64_t2, int64_t2); 1804 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1805 int64_t3 min(int64_t3, int64_t3); 1806 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1807 int64_t4 min(int64_t4, int64_t4); 1808 1809 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1810 uint64_t min(uint64_t, uint64_t); 1811 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1812 uint64_t2 min(uint64_t2, uint64_t2); 1813 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1814 uint64_t3 min(uint64_t3, uint64_t3); 1815 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1816 uint64_t4 min(uint64_t4, uint64_t4); 1817 1818 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1819 double min(double, double); 1820 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1821 double2 min(double2, double2); 1822 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1823 double3 min(double3, double3); 1824 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) 1825 double4 min(double4, double4); 1826 1827 //===----------------------------------------------------------------------===// 1828 // normalize builtins 1829 //===----------------------------------------------------------------------===// 1830 1831 /// \fn T normalize(T x) 1832 /// \brief Returns the normalized unit vector of the specified floating-point 1833 /// vector. \param x [in] The vector of floats. 1834 /// 1835 /// Normalize is based on the following formula: x / length(x). 1836 1837 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1838 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1839 half normalize(half); 1840 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1841 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1842 half2 normalize(half2); 1843 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1844 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1845 half3 normalize(half3); 1846 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1847 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1848 half4 normalize(half4); 1849 1850 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1851 float normalize(float); 1852 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1853 float2 normalize(float2); 1854 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1855 float3 normalize(float3); 1856 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_normalize) 1857 float4 normalize(float4); 1858 1859 //===----------------------------------------------------------------------===// 1860 // pow builtins 1861 //===----------------------------------------------------------------------===// 1862 1863 /// \fn T pow(T Val, T Pow) 1864 /// \brief Return the value \a Val, raised to the power \a Pow. 1865 /// \param Val The input value. 1866 /// \param Pow The specified power. 1867 1868 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1869 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1870 half pow(half, half); 1871 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1872 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1873 half2 pow(half2, half2); 1874 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1875 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1876 half3 pow(half3, half3); 1877 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1878 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1879 half4 pow(half4, half4); 1880 1881 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1882 float pow(float, float); 1883 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1884 float2 pow(float2, float2); 1885 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1886 float3 pow(float3, float3); 1887 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) 1888 float4 pow(float4, float4); 1889 1890 //===----------------------------------------------------------------------===// 1891 // reversebits builtins 1892 //===----------------------------------------------------------------------===// 1893 1894 /// \fn T reversebits(T Val) 1895 /// \brief Return the value \a Val with the bit order reversed. 1896 /// \param Val The input value. 1897 1898 #ifdef __HLSL_ENABLE_16_BIT 1899 _HLSL_AVAILABILITY(shadermodel, 6.2) 1900 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1901 uint16_t reversebits(uint16_t); 1902 _HLSL_AVAILABILITY(shadermodel, 6.2) 1903 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1904 uint16_t2 reversebits(uint16_t2); 1905 _HLSL_AVAILABILITY(shadermodel, 6.2) 1906 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1907 uint16_t3 reversebits(uint16_t3); 1908 _HLSL_AVAILABILITY(shadermodel, 6.2) 1909 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1910 uint16_t4 reversebits(uint16_t4); 1911 #endif 1912 1913 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1914 uint reversebits(uint); 1915 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1916 uint2 reversebits(uint2); 1917 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1918 uint3 reversebits(uint3); 1919 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1920 uint4 reversebits(uint4); 1921 1922 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1923 uint64_t reversebits(uint64_t); 1924 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1925 uint64_t2 reversebits(uint64_t2); 1926 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1927 uint64_t3 reversebits(uint64_t3); 1928 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) 1929 uint64_t4 reversebits(uint64_t4); 1930 1931 //===----------------------------------------------------------------------===// 1932 // cross builtins 1933 //===----------------------------------------------------------------------===// 1934 1935 /// \fn T cross(T x, T y) 1936 /// \brief Returns the cross product of two floating-point, 3D vectors. 1937 /// \param x [in] The first floating-point, 3D vector. 1938 /// \param y [in] The second floating-point, 3D vector. 1939 /// 1940 /// Result is the cross product of x and y, i.e., the resulting 1941 /// components are, in order : 1942 /// x[1] * y[2] - y[1] * x[2] 1943 /// x[2] * y[0] - y[2] * x[0] 1944 /// x[0] * y[1] - y[0] * x[1] 1945 1946 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1947 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_cross) 1948 half3 cross(half3, half3); 1949 1950 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_cross) 1951 float3 cross(float3, float3); 1952 1953 //===----------------------------------------------------------------------===// 1954 // D3DCOLORtoUBYTE4 builtin 1955 //===----------------------------------------------------------------------===// 1956 1957 /// \fn T D3DCOLORtoUBYTE4(T x) 1958 /// \brief Converts a floating-point, 4D vector set by a D3DCOLOR to a UBYTE4. 1959 /// \param x [in] The floating-point vector4 to convert. 1960 /// 1961 /// The return value is the UBYTE4 representation of the \a x parameter. 1962 /// 1963 /// This function swizzles and scales components of the \a x parameter. Use this 1964 /// function to compensate for the lack of UBYTE4 support in some hardware. 1965 1966 constexpr vector<uint, 4> D3DCOLORtoUBYTE4(vector<float, 4> V) { 1967 return __detail::d3d_color_to_ubyte4_impl(V); 1968 } 1969 1970 //===----------------------------------------------------------------------===// 1971 // rcp builtins 1972 //===----------------------------------------------------------------------===// 1973 1974 /// \fn T rcp(T x) 1975 /// \brief Calculates a fast, approximate, per-component reciprocal ie 1 / \a x. 1976 /// \param x The specified input value. 1977 /// 1978 /// The return value is the reciprocal of the \a x parameter. 1979 1980 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1981 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 1982 half rcp(half); 1983 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1984 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 1985 half2 rcp(half2); 1986 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1987 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 1988 half3 rcp(half3); 1989 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 1990 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 1991 half4 rcp(half4); 1992 1993 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 1994 float rcp(float); 1995 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 1996 float2 rcp(float2); 1997 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 1998 float3 rcp(float3); 1999 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 2000 float4 rcp(float4); 2001 2002 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 2003 double rcp(double); 2004 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 2005 double2 rcp(double2); 2006 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 2007 double3 rcp(double3); 2008 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) 2009 double4 rcp(double4); 2010 2011 //===----------------------------------------------------------------------===// 2012 // rsqrt builtins 2013 //===----------------------------------------------------------------------===// 2014 2015 /// \fn T rsqrt(T x) 2016 /// \brief Returns the reciprocal of the square root of the specified value. 2017 /// ie 1 / sqrt( \a x). 2018 /// \param x The specified input value. 2019 /// 2020 /// This function uses the following formula: 1 / sqrt(x). 2021 2022 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2023 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2024 half rsqrt(half); 2025 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2026 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2027 half2 rsqrt(half2); 2028 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2029 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2030 half3 rsqrt(half3); 2031 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2032 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2033 half4 rsqrt(half4); 2034 2035 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2036 float rsqrt(float); 2037 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2038 float2 rsqrt(float2); 2039 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2040 float3 rsqrt(float3); 2041 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) 2042 float4 rsqrt(float4); 2043 2044 //===----------------------------------------------------------------------===// 2045 // round builtins 2046 //===----------------------------------------------------------------------===// 2047 2048 /// \fn T round(T x) 2049 /// \brief Rounds the specified value \a x to the nearest integer. 2050 /// \param x The specified input value. 2051 /// 2052 /// The return value is the \a x parameter, rounded to the nearest integer 2053 /// within a floating-point type. Halfway cases are 2054 /// rounded to the nearest even value. 2055 2056 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2057 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2058 half round(half); 2059 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2060 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2061 half2 round(half2); 2062 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2063 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2064 half3 round(half3); 2065 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2066 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2067 half4 round(half4); 2068 2069 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2070 float round(float); 2071 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2072 float2 round(float2); 2073 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2074 float3 round(float3); 2075 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) 2076 float4 round(float4); 2077 2078 //===----------------------------------------------------------------------===// 2079 // saturate builtins 2080 //===----------------------------------------------------------------------===// 2081 2082 /// \fn T saturate(T Val) 2083 /// \brief Returns input value, \a Val, clamped within the range of 0.0f 2084 /// to 1.0f. \param Val The input value. 2085 2086 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2087 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2088 half saturate(half); 2089 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2090 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2091 half2 saturate(half2); 2092 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2093 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2094 half3 saturate(half3); 2095 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2096 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2097 half4 saturate(half4); 2098 2099 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2100 float saturate(float); 2101 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2102 float2 saturate(float2); 2103 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2104 float3 saturate(float3); 2105 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2106 float4 saturate(float4); 2107 2108 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2109 double saturate(double); 2110 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2111 double2 saturate(double2); 2112 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2113 double3 saturate(double3); 2114 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_saturate) 2115 double4 saturate(double4); 2116 2117 //===----------------------------------------------------------------------===// 2118 // select builtins 2119 //===----------------------------------------------------------------------===// 2120 2121 /// \fn T select(bool Cond, T TrueVal, T FalseVal) 2122 /// \brief ternary operator. 2123 /// \param Cond The Condition input value. 2124 /// \param TrueVal The Value returned if Cond is true. 2125 /// \param FalseVal The Value returned if Cond is false. 2126 2127 template <typename T> 2128 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_select) 2129 T select(bool, T, T); 2130 2131 /// \fn vector<T,Sz> select(vector<bool,Sz> Conds, vector<T,Sz> TrueVals, 2132 /// vector<T,Sz> FalseVals) 2133 /// \brief ternary operator for vectors. All vectors must be the same size. 2134 /// \param Conds The Condition input values. 2135 /// \param TrueVals The vector values are chosen from when conditions are true. 2136 /// \param FalseVals The vector values are chosen from when conditions are 2137 /// false. 2138 2139 template <typename T, int Sz> 2140 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_select) 2141 vector<T, Sz> select(vector<bool, Sz>, vector<T, Sz>, vector<T, Sz>); 2142 2143 //===----------------------------------------------------------------------===// 2144 // sin builtins 2145 //===----------------------------------------------------------------------===// 2146 2147 /// \fn T sin(T Val) 2148 /// \brief Returns the sine of the input value, \a Val. 2149 /// \param Val The input value. 2150 2151 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2152 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2153 half sin(half); 2154 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2155 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2156 half2 sin(half2); 2157 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2158 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2159 half3 sin(half3); 2160 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2161 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2162 half4 sin(half4); 2163 2164 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2165 float sin(float); 2166 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2167 float2 sin(float2); 2168 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2169 float3 sin(float3); 2170 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) 2171 float4 sin(float4); 2172 2173 //===----------------------------------------------------------------------===// 2174 // sinh builtins 2175 //===----------------------------------------------------------------------===// 2176 2177 /// \fn T sinh(T Val) 2178 /// \brief Returns the hyperbolic sine of the input value, \a Val. 2179 /// \param Val The input value. 2180 2181 #ifdef __HLSL_ENABLE_16_BIT 2182 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2183 half sinh(half); 2184 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2185 half2 sinh(half2); 2186 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2187 half3 sinh(half3); 2188 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2189 half4 sinh(half4); 2190 #endif 2191 2192 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2193 float sinh(float); 2194 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2195 float2 sinh(float2); 2196 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2197 float3 sinh(float3); 2198 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sinh) 2199 float4 sinh(float4); 2200 2201 //===----------------------------------------------------------------------===// 2202 // sqrt builtins 2203 //===----------------------------------------------------------------------===// 2204 2205 /// \fn T sqrt(T Val) 2206 /// \brief Returns the square root of the input value, \a Val. 2207 /// \param Val The input value. 2208 2209 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2210 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2211 half sqrt(half); 2212 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2213 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2214 half2 sqrt(half2); 2215 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2216 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2217 half3 sqrt(half3); 2218 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2219 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2220 half4 sqrt(half4); 2221 2222 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2223 float sqrt(float); 2224 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2225 float2 sqrt(float2); 2226 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2227 float3 sqrt(float3); 2228 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) 2229 float4 sqrt(float4); 2230 2231 //===----------------------------------------------------------------------===// 2232 // step builtins 2233 //===----------------------------------------------------------------------===// 2234 2235 /// \fn T step(T x, T y) 2236 /// \brief Returns 1 if the x parameter is greater than or equal to the y 2237 /// parameter; otherwise, 0. vector. \param x [in] The first floating-point 2238 /// value to compare. \param y [in] The first floating-point value to compare. 2239 /// 2240 /// Step is based on the following formula: (x >= y) ? 1 : 0 2241 2242 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2243 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2244 half step(half, half); 2245 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2246 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2247 half2 step(half2, half2); 2248 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2249 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2250 half3 step(half3, half3); 2251 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2252 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2253 half4 step(half4, half4); 2254 2255 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2256 float step(float, float); 2257 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2258 float2 step(float2, float2); 2259 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2260 float3 step(float3, float3); 2261 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_step) 2262 float4 step(float4, float4); 2263 2264 //===----------------------------------------------------------------------===// 2265 // tan builtins 2266 //===----------------------------------------------------------------------===// 2267 2268 /// \fn T tan(T Val) 2269 /// \brief Returns the tangent of the input value, \a Val. 2270 /// \param Val The input value. 2271 2272 #ifdef __HLSL_ENABLE_16_BIT 2273 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2274 half tan(half); 2275 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2276 half2 tan(half2); 2277 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2278 half3 tan(half3); 2279 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2280 half4 tan(half4); 2281 #endif 2282 2283 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2284 float tan(float); 2285 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2286 float2 tan(float2); 2287 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2288 float3 tan(float3); 2289 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tan) 2290 float4 tan(float4); 2291 2292 //===----------------------------------------------------------------------===// 2293 // tanh builtins 2294 //===----------------------------------------------------------------------===// 2295 2296 /// \fn T tanh(T Val) 2297 /// \brief Returns the hyperbolic tangent of the input value, \a Val. 2298 /// \param Val The input value. 2299 2300 #ifdef __HLSL_ENABLE_16_BIT 2301 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2302 half tanh(half); 2303 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2304 half2 tanh(half2); 2305 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2306 half3 tanh(half3); 2307 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2308 half4 tanh(half4); 2309 #endif 2310 2311 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2312 float tanh(float); 2313 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2314 float2 tanh(float2); 2315 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2316 float3 tanh(float3); 2317 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_tanh) 2318 float4 tanh(float4); 2319 2320 //===----------------------------------------------------------------------===// 2321 // trunc builtins 2322 //===----------------------------------------------------------------------===// 2323 2324 /// \fn T trunc(T Val) 2325 /// \brief Returns the truncated integer value of the input value, \a Val. 2326 /// \param Val The input value. 2327 2328 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2329 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2330 half trunc(half); 2331 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2332 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2333 half2 trunc(half2); 2334 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2335 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2336 half3 trunc(half3); 2337 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2338 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2339 half4 trunc(half4); 2340 2341 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2342 float trunc(float); 2343 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2344 float2 trunc(float2); 2345 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2346 float3 trunc(float3); 2347 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) 2348 float4 trunc(float4); 2349 2350 //===----------------------------------------------------------------------===// 2351 // Wave* builtins 2352 //===----------------------------------------------------------------------===// 2353 2354 /// \brief Returns true if the expression is true in all active lanes in the 2355 /// current wave. 2356 /// 2357 /// \param Val The boolean expression to evaluate. 2358 /// \return True if the expression is true in all lanes. 2359 _HLSL_AVAILABILITY(shadermodel, 6.0) 2360 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_all_true) 2361 __attribute__((convergent)) bool WaveActiveAllTrue(bool Val); 2362 2363 /// \brief Returns true if the expression is true in any active lane in the 2364 /// current wave. 2365 /// 2366 /// \param Val The boolean expression to evaluate. 2367 /// \return True if the expression is true in any lane. 2368 _HLSL_AVAILABILITY(shadermodel, 6.0) 2369 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_any_true) 2370 __attribute__((convergent)) bool WaveActiveAnyTrue(bool Val); 2371 2372 /// \brief Counts the number of boolean variables which evaluate to true across 2373 /// all active lanes in the current wave. 2374 /// 2375 /// \param Val The input boolean value. 2376 /// \return The number of lanes for which the boolean variable evaluates to 2377 /// true, across all active lanes in the current wave. 2378 _HLSL_AVAILABILITY(shadermodel, 6.0) 2379 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_count_bits) 2380 __attribute__((convergent)) uint WaveActiveCountBits(bool Val); 2381 2382 /// \brief Returns the index of the current lane within the current wave. 2383 _HLSL_AVAILABILITY(shadermodel, 6.0) 2384 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_index) 2385 __attribute__((convergent)) uint WaveGetLaneIndex(); 2386 2387 _HLSL_AVAILABILITY(shadermodel, 6.0) 2388 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_is_first_lane) 2389 __attribute__((convergent)) bool WaveIsFirstLane(); 2390 2391 //===----------------------------------------------------------------------===// 2392 // WaveReadLaneAt builtins 2393 //===----------------------------------------------------------------------===// 2394 2395 // \brief Returns the value of the expression for the given lane index within 2396 // the specified wave. 2397 2398 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2399 __attribute__((convergent)) bool WaveReadLaneAt(bool, int32_t); 2400 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2401 __attribute__((convergent)) bool2 WaveReadLaneAt(bool2, int32_t); 2402 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2403 __attribute__((convergent)) bool3 WaveReadLaneAt(bool3, int32_t); 2404 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2405 __attribute__((convergent)) bool4 WaveReadLaneAt(bool4, int32_t); 2406 2407 #ifdef __HLSL_ENABLE_16_BIT 2408 _HLSL_AVAILABILITY(shadermodel, 6.0) 2409 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2410 __attribute__((convergent)) int16_t WaveReadLaneAt(int16_t, int32_t); 2411 _HLSL_AVAILABILITY(shadermodel, 6.0) 2412 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2413 __attribute__((convergent)) int16_t2 WaveReadLaneAt(int16_t2, int32_t); 2414 _HLSL_AVAILABILITY(shadermodel, 6.0) 2415 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2416 __attribute__((convergent)) int16_t3 WaveReadLaneAt(int16_t3, int32_t); 2417 _HLSL_AVAILABILITY(shadermodel, 6.0) 2418 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2419 __attribute__((convergent)) int16_t4 WaveReadLaneAt(int16_t4, int32_t); 2420 #endif 2421 2422 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2423 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2424 __attribute__((convergent)) half WaveReadLaneAt(half, int32_t); 2425 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2426 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2427 __attribute__((convergent)) half2 WaveReadLaneAt(half2, int32_t); 2428 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2429 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2430 __attribute__((convergent)) half3 WaveReadLaneAt(half3, int32_t); 2431 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2432 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2433 __attribute__((convergent)) half4 WaveReadLaneAt(half4, int32_t); 2434 2435 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2436 __attribute__((convergent)) int WaveReadLaneAt(int, int32_t); 2437 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2438 __attribute__((convergent)) int2 WaveReadLaneAt(int2, int32_t); 2439 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2440 __attribute__((convergent)) int3 WaveReadLaneAt(int3, int32_t); 2441 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2442 __attribute__((convergent)) int4 WaveReadLaneAt(int4, int32_t); 2443 2444 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2445 __attribute__((convergent)) float WaveReadLaneAt(float, int32_t); 2446 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2447 __attribute__((convergent)) float2 WaveReadLaneAt(float2, int32_t); 2448 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2449 __attribute__((convergent)) float3 WaveReadLaneAt(float3, int32_t); 2450 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2451 __attribute__((convergent)) float4 WaveReadLaneAt(float4, int32_t); 2452 2453 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2454 __attribute__((convergent)) int64_t WaveReadLaneAt(int64_t, int32_t); 2455 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2456 __attribute__((convergent)) int64_t2 WaveReadLaneAt(int64_t2, int32_t); 2457 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2458 __attribute__((convergent)) int64_t3 WaveReadLaneAt(int64_t3, int32_t); 2459 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2460 __attribute__((convergent)) int64_t4 WaveReadLaneAt(int64_t4, int32_t); 2461 2462 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2463 __attribute__((convergent)) double WaveReadLaneAt(double, int32_t); 2464 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2465 __attribute__((convergent)) double2 WaveReadLaneAt(double2, int32_t); 2466 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2467 __attribute__((convergent)) double3 WaveReadLaneAt(double3, int32_t); 2468 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_read_lane_at) 2469 __attribute__((convergent)) double4 WaveReadLaneAt(double4, int32_t); 2470 2471 //===----------------------------------------------------------------------===// 2472 // WaveActiveMax builtins 2473 //===----------------------------------------------------------------------===// 2474 2475 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2476 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2477 __attribute__((convergent)) half WaveActiveMax(half); 2478 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2479 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2480 __attribute__((convergent)) half2 WaveActiveMax(half2); 2481 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2482 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2483 __attribute__((convergent)) half3 WaveActiveMax(half3); 2484 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2485 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2486 __attribute__((convergent)) half4 WaveActiveMax(half4); 2487 2488 #ifdef __HLSL_ENABLE_16_BIT 2489 _HLSL_AVAILABILITY(shadermodel, 6.0) 2490 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2491 __attribute__((convergent)) int16_t WaveActiveMax(int16_t); 2492 _HLSL_AVAILABILITY(shadermodel, 6.0) 2493 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2494 __attribute__((convergent)) int16_t2 WaveActiveMax(int16_t2); 2495 _HLSL_AVAILABILITY(shadermodel, 6.0) 2496 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2497 __attribute__((convergent)) int16_t3 WaveActiveMax(int16_t3); 2498 _HLSL_AVAILABILITY(shadermodel, 6.0) 2499 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2500 __attribute__((convergent)) int16_t4 WaveActiveMax(int16_t4); 2501 2502 _HLSL_AVAILABILITY(shadermodel, 6.0) 2503 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2504 __attribute__((convergent)) uint16_t WaveActiveMax(uint16_t); 2505 _HLSL_AVAILABILITY(shadermodel, 6.0) 2506 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2507 __attribute__((convergent)) uint16_t2 WaveActiveMax(uint16_t2); 2508 _HLSL_AVAILABILITY(shadermodel, 6.0) 2509 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2510 __attribute__((convergent)) uint16_t3 WaveActiveMax(uint16_t3); 2511 _HLSL_AVAILABILITY(shadermodel, 6.0) 2512 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2513 __attribute__((convergent)) uint16_t4 WaveActiveMax(uint16_t4); 2514 #endif 2515 2516 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2517 __attribute__((convergent)) int WaveActiveMax(int); 2518 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2519 __attribute__((convergent)) int2 WaveActiveMax(int2); 2520 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2521 __attribute__((convergent)) int3 WaveActiveMax(int3); 2522 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2523 __attribute__((convergent)) int4 WaveActiveMax(int4); 2524 2525 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2526 __attribute__((convergent)) uint WaveActiveMax(uint); 2527 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2528 __attribute__((convergent)) uint2 WaveActiveMax(uint2); 2529 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2530 __attribute__((convergent)) uint3 WaveActiveMax(uint3); 2531 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2532 __attribute__((convergent)) uint4 WaveActiveMax(uint4); 2533 2534 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2535 __attribute__((convergent)) int64_t WaveActiveMax(int64_t); 2536 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2537 __attribute__((convergent)) int64_t2 WaveActiveMax(int64_t2); 2538 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2539 __attribute__((convergent)) int64_t3 WaveActiveMax(int64_t3); 2540 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2541 __attribute__((convergent)) int64_t4 WaveActiveMax(int64_t4); 2542 2543 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2544 __attribute__((convergent)) uint64_t WaveActiveMax(uint64_t); 2545 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2546 __attribute__((convergent)) uint64_t2 WaveActiveMax(uint64_t2); 2547 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2548 __attribute__((convergent)) uint64_t3 WaveActiveMax(uint64_t3); 2549 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2550 __attribute__((convergent)) uint64_t4 WaveActiveMax(uint64_t4); 2551 2552 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2553 __attribute__((convergent)) float WaveActiveMax(float); 2554 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2555 __attribute__((convergent)) float2 WaveActiveMax(float2); 2556 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2557 __attribute__((convergent)) float3 WaveActiveMax(float3); 2558 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2559 __attribute__((convergent)) float4 WaveActiveMax(float4); 2560 2561 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2562 __attribute__((convergent)) double WaveActiveMax(double); 2563 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2564 __attribute__((convergent)) double2 WaveActiveMax(double2); 2565 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2566 __attribute__((convergent)) double3 WaveActiveMax(double3); 2567 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_max) 2568 __attribute__((convergent)) double4 WaveActiveMax(double4); 2569 2570 //===----------------------------------------------------------------------===// 2571 // WaveActiveSum builtins 2572 //===----------------------------------------------------------------------===// 2573 2574 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2575 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2576 __attribute__((convergent)) half WaveActiveSum(half); 2577 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2578 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2579 __attribute__((convergent)) half2 WaveActiveSum(half2); 2580 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2581 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2582 __attribute__((convergent)) half3 WaveActiveSum(half3); 2583 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.0) 2584 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2585 __attribute__((convergent)) half4 WaveActiveSum(half4); 2586 2587 #ifdef __HLSL_ENABLE_16_BIT 2588 _HLSL_AVAILABILITY(shadermodel, 6.0) 2589 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2590 __attribute__((convergent)) int16_t WaveActiveSum(int16_t); 2591 _HLSL_AVAILABILITY(shadermodel, 6.0) 2592 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2593 __attribute__((convergent)) int16_t2 WaveActiveSum(int16_t2); 2594 _HLSL_AVAILABILITY(shadermodel, 6.0) 2595 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2596 __attribute__((convergent)) int16_t3 WaveActiveSum(int16_t3); 2597 _HLSL_AVAILABILITY(shadermodel, 6.0) 2598 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2599 __attribute__((convergent)) int16_t4 WaveActiveSum(int16_t4); 2600 2601 _HLSL_AVAILABILITY(shadermodel, 6.0) 2602 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2603 __attribute__((convergent)) uint16_t WaveActiveSum(uint16_t); 2604 _HLSL_AVAILABILITY(shadermodel, 6.0) 2605 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2606 __attribute__((convergent)) uint16_t2 WaveActiveSum(uint16_t2); 2607 _HLSL_AVAILABILITY(shadermodel, 6.0) 2608 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2609 __attribute__((convergent)) uint16_t3 WaveActiveSum(uint16_t3); 2610 _HLSL_AVAILABILITY(shadermodel, 6.0) 2611 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2612 __attribute__((convergent)) uint16_t4 WaveActiveSum(uint16_t4); 2613 #endif 2614 2615 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2616 __attribute__((convergent)) int WaveActiveSum(int); 2617 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2618 __attribute__((convergent)) int2 WaveActiveSum(int2); 2619 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2620 __attribute__((convergent)) int3 WaveActiveSum(int3); 2621 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2622 __attribute__((convergent)) int4 WaveActiveSum(int4); 2623 2624 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2625 __attribute__((convergent)) uint WaveActiveSum(uint); 2626 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2627 __attribute__((convergent)) uint2 WaveActiveSum(uint2); 2628 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2629 __attribute__((convergent)) uint3 WaveActiveSum(uint3); 2630 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2631 __attribute__((convergent)) uint4 WaveActiveSum(uint4); 2632 2633 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2634 __attribute__((convergent)) int64_t WaveActiveSum(int64_t); 2635 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2636 __attribute__((convergent)) int64_t2 WaveActiveSum(int64_t2); 2637 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2638 __attribute__((convergent)) int64_t3 WaveActiveSum(int64_t3); 2639 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2640 __attribute__((convergent)) int64_t4 WaveActiveSum(int64_t4); 2641 2642 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2643 __attribute__((convergent)) uint64_t WaveActiveSum(uint64_t); 2644 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2645 __attribute__((convergent)) uint64_t2 WaveActiveSum(uint64_t2); 2646 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2647 __attribute__((convergent)) uint64_t3 WaveActiveSum(uint64_t3); 2648 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2649 __attribute__((convergent)) uint64_t4 WaveActiveSum(uint64_t4); 2650 2651 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2652 __attribute__((convergent)) float WaveActiveSum(float); 2653 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2654 __attribute__((convergent)) float2 WaveActiveSum(float2); 2655 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2656 __attribute__((convergent)) float3 WaveActiveSum(float3); 2657 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2658 __attribute__((convergent)) float4 WaveActiveSum(float4); 2659 2660 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2661 __attribute__((convergent)) double WaveActiveSum(double); 2662 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2663 __attribute__((convergent)) double2 WaveActiveSum(double2); 2664 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2665 __attribute__((convergent)) double3 WaveActiveSum(double3); 2666 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_sum) 2667 __attribute__((convergent)) double4 WaveActiveSum(double4); 2668 2669 //===----------------------------------------------------------------------===// 2670 // sign builtins 2671 //===----------------------------------------------------------------------===// 2672 2673 /// \fn T sign(T Val) 2674 /// \brief Returns -1 if \a Val is less than zero; 0 if \a Val equals zero; and 2675 /// 1 if \a Val is greater than zero. \param Val The input value. 2676 2677 #ifdef __HLSL_ENABLE_16_BIT 2678 _HLSL_AVAILABILITY(shadermodel, 6.2) 2679 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2680 int sign(int16_t); 2681 _HLSL_AVAILABILITY(shadermodel, 6.2) 2682 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2683 int2 sign(int16_t2); 2684 _HLSL_AVAILABILITY(shadermodel, 6.2) 2685 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2686 int3 sign(int16_t3); 2687 _HLSL_AVAILABILITY(shadermodel, 6.2) 2688 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2689 int4 sign(int16_t4); 2690 2691 _HLSL_AVAILABILITY(shadermodel, 6.2) 2692 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2693 int sign(uint16_t); 2694 _HLSL_AVAILABILITY(shadermodel, 6.2) 2695 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2696 int2 sign(uint16_t2); 2697 _HLSL_AVAILABILITY(shadermodel, 6.2) 2698 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2699 int3 sign(uint16_t3); 2700 _HLSL_AVAILABILITY(shadermodel, 6.2) 2701 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2702 int4 sign(uint16_t4); 2703 #endif 2704 2705 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2706 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2707 int sign(half); 2708 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2709 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2710 int2 sign(half2); 2711 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2712 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2713 int3 sign(half3); 2714 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2715 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2716 int4 sign(half4); 2717 2718 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2719 int sign(int); 2720 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2721 int2 sign(int2); 2722 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2723 int3 sign(int3); 2724 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2725 int4 sign(int4); 2726 2727 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2728 int sign(uint); 2729 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2730 int2 sign(uint2); 2731 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2732 int3 sign(uint3); 2733 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2734 int4 sign(uint4); 2735 2736 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2737 int sign(float); 2738 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2739 int2 sign(float2); 2740 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2741 int3 sign(float3); 2742 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2743 int4 sign(float4); 2744 2745 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2746 int sign(int64_t); 2747 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2748 int2 sign(int64_t2); 2749 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2750 int3 sign(int64_t3); 2751 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2752 int4 sign(int64_t4); 2753 2754 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2755 int sign(uint64_t); 2756 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2757 int2 sign(uint64_t2); 2758 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2759 int3 sign(uint64_t3); 2760 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2761 int4 sign(uint64_t4); 2762 2763 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2764 int sign(double); 2765 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2766 int2 sign(double2); 2767 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2768 int3 sign(double3); 2769 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_sign) 2770 int4 sign(double4); 2771 2772 //===----------------------------------------------------------------------===// 2773 // radians builtins 2774 //===----------------------------------------------------------------------===// 2775 2776 /// \fn T radians(T Val) 2777 /// \brief Converts the specified value from degrees to radians. 2778 2779 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2780 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2781 half radians(half); 2782 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2783 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2784 half2 radians(half2); 2785 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2786 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2787 half3 radians(half3); 2788 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) 2789 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2790 half4 radians(half4); 2791 2792 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2793 float radians(float); 2794 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2795 float2 radians(float2); 2796 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2797 float3 radians(float3); 2798 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_radians) 2799 float4 radians(float4); 2800 2801 //===----------------------------------------------------------------------===// 2802 // GroupMemoryBarrierWithGroupSync builtins 2803 //===----------------------------------------------------------------------===// 2804 2805 /// \fn void GroupMemoryBarrierWithGroupSync(void) 2806 /// \brief Blocks execution of all threads in a group until all group shared 2807 /// accesses have been completed and all threads in the group have reached this 2808 /// call. 2809 2810 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_group_memory_barrier_with_group_sync) 2811 void GroupMemoryBarrierWithGroupSync(void); 2812 2813 } // namespace hlsl 2814 #endif //_HLSL_HLSL_INTRINSICS_H_ 2815