clang 24.0.0git
hlsl_compat_overloads.h
Go to the documentation of this file.
1//===--- hlsl_compat_overloads.h - Extra HLSL overloads for intrinsics ----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _HLSL_COMPAT_OVERLOADS_H_
10#define _HLSL_COMPAT_OVERLOADS_H_
11
12namespace hlsl {
13
14// Note: Functions in this file are sorted alphabetically, then grouped by base
15// element type, and the element types are sorted by size, then signed integer,
16// unsigned integer and floating point. Keeping this ordering consistent will
17// help keep this file manageable as it grows.
18
19#define _DXC_DEPRECATED_64BIT_FN(fn) \
20 [[deprecated("In 202x 64 bit API lowering for " #fn " is deprecated. " \
21 "Explicitly cast parameters to 32 or 16 bit types.")]]
22
23#define _DXC_DEPRECATED_INT_FN(fn) \
24 [[deprecated("In 202x int lowering for " #fn " is deprecated. " \
25 "Explicitly cast parameters to float types.")]]
26
27#define _DXC_DEPRECATED_VEC_SCALAR_FN(fn) \
28 [[deprecated("In 202x mismatched vector/scalar lowering for " #fn " is " \
29 "deprecated. Explicitly cast parameters.")]]
30
31#define _DXC_DEPRECATED_SCALAR_FN(ty1, ty2, fn) \
32 [[deprecated("In 202x mismatched " #ty1 "/" #ty2 " lowering for " #fn " is " \
33 "deprecated. Explicitly cast parameters.")]]
34
35#define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn) \
36 _DXC_DEPRECATED_64BIT_FN(fn) \
37 constexpr float fn(double V) { return fn((float)V); } \
38 _DXC_DEPRECATED_64BIT_FN(fn) \
39 constexpr float2 fn(double2 V) { return fn((float2)V); } \
40 _DXC_DEPRECATED_64BIT_FN(fn) \
41 constexpr float3 fn(double3 V) { return fn((float3)V); } \
42 _DXC_DEPRECATED_64BIT_FN(fn) \
43 constexpr float4 fn(double4 V) { return fn((float4)V); }
44
45#define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn) \
46 _DXC_DEPRECATED_64BIT_FN(fn) \
47 constexpr float fn(double V1, double V2) { \
48 return fn((float)V1, (float)V2); \
49 } \
50 _DXC_DEPRECATED_64BIT_FN(fn) \
51 constexpr float2 fn(double2 V1, double2 V2) { \
52 return fn((float2)V1, (float2)V2); \
53 } \
54 _DXC_DEPRECATED_64BIT_FN(fn) \
55 constexpr float3 fn(double3 V1, double3 V2) { \
56 return fn((float3)V1, (float3)V2); \
57 } \
58 _DXC_DEPRECATED_64BIT_FN(fn) \
59 constexpr float4 fn(double4 V1, double4 V2) { \
60 return fn((float4)V1, (float4)V2); \
61 }
62
63#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn) \
64 _DXC_DEPRECATED_64BIT_FN(fn) \
65 constexpr float fn(double V1, double V2, double V3) { \
66 return fn((float)V1, (float)V2, (float)V3); \
67 } \
68 _DXC_DEPRECATED_64BIT_FN(fn) \
69 constexpr float2 fn(double2 V1, double2 V2, double2 V3) { \
70 return fn((float2)V1, (float2)V2, (float2)V3); \
71 } \
72 _DXC_DEPRECATED_64BIT_FN(fn) \
73 constexpr float3 fn(double3 V1, double3 V2, double3 V3) { \
74 return fn((float3)V1, (float3)V2, (float3)V3); \
75 } \
76 _DXC_DEPRECATED_64BIT_FN(fn) \
77 constexpr float4 fn(double4 V1, double4 V2, double4 V3) { \
78 return fn((float4)V1, (float4)V2, (float4)V3); \
79 }
80
81#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn) \
82 _DXC_DEPRECATED_INT_FN(fn) \
83 constexpr float fn(int V) { return fn((float)V); } \
84 _DXC_DEPRECATED_INT_FN(fn) \
85 constexpr float2 fn(int2 V) { return fn((float2)V); } \
86 _DXC_DEPRECATED_INT_FN(fn) \
87 constexpr float3 fn(int3 V) { return fn((float3)V); } \
88 _DXC_DEPRECATED_INT_FN(fn) \
89 constexpr float4 fn(int4 V) { return fn((float4)V); } \
90 _DXC_DEPRECATED_INT_FN(fn) \
91 constexpr float fn(uint V) { return fn((float)V); } \
92 _DXC_DEPRECATED_INT_FN(fn) \
93 constexpr float2 fn(uint2 V) { return fn((float2)V); } \
94 _DXC_DEPRECATED_INT_FN(fn) \
95 constexpr float3 fn(uint3 V) { return fn((float3)V); } \
96 _DXC_DEPRECATED_INT_FN(fn) \
97 constexpr float4 fn(uint4 V) { return fn((float4)V); } \
98 _DXC_DEPRECATED_INT_FN(fn) \
99 constexpr float fn(int64_t V) { return fn((float)V); } \
100 _DXC_DEPRECATED_INT_FN(fn) \
101 constexpr float2 fn(int64_t2 V) { return fn((float2)V); } \
102 _DXC_DEPRECATED_INT_FN(fn) \
103 constexpr float3 fn(int64_t3 V) { return fn((float3)V); } \
104 _DXC_DEPRECATED_INT_FN(fn) \
105 constexpr float4 fn(int64_t4 V) { return fn((float4)V); } \
106 _DXC_DEPRECATED_INT_FN(fn) \
107 constexpr float fn(uint64_t V) { return fn((float)V); } \
108 _DXC_DEPRECATED_INT_FN(fn) \
109 constexpr float2 fn(uint64_t2 V) { return fn((float2)V); } \
110 _DXC_DEPRECATED_INT_FN(fn) \
111 constexpr float3 fn(uint64_t3 V) { return fn((float3)V); } \
112 _DXC_DEPRECATED_INT_FN(fn) \
113 constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }
114
115#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn) \
116 _DXC_DEPRECATED_INT_FN(fn) \
117 constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); } \
118 _DXC_DEPRECATED_INT_FN(fn) \
119 constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \
120 _DXC_DEPRECATED_INT_FN(fn) \
121 constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \
122 _DXC_DEPRECATED_INT_FN(fn) \
123 constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \
124 _DXC_DEPRECATED_INT_FN(fn) \
125 constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); } \
126 _DXC_DEPRECATED_INT_FN(fn) \
127 constexpr float2 fn(uint2 V1, uint2 V2) { \
128 return fn((float2)V1, (float2)V2); \
129 } \
130 _DXC_DEPRECATED_INT_FN(fn) \
131 constexpr float3 fn(uint3 V1, uint3 V2) { \
132 return fn((float3)V1, (float3)V2); \
133 } \
134 _DXC_DEPRECATED_INT_FN(fn) \
135 constexpr float4 fn(uint4 V1, uint4 V2) { \
136 return fn((float4)V1, (float4)V2); \
137 } \
138 _DXC_DEPRECATED_INT_FN(fn) \
139 constexpr float fn(int64_t V1, int64_t V2) { \
140 return fn((float)V1, (float)V2); \
141 } \
142 _DXC_DEPRECATED_INT_FN(fn) \
143 constexpr float2 fn(int64_t2 V1, int64_t2 V2) { \
144 return fn((float2)V1, (float2)V2); \
145 } \
146 _DXC_DEPRECATED_INT_FN(fn) \
147 constexpr float3 fn(int64_t3 V1, int64_t3 V2) { \
148 return fn((float3)V1, (float3)V2); \
149 } \
150 _DXC_DEPRECATED_INT_FN(fn) \
151 constexpr float4 fn(int64_t4 V1, int64_t4 V2) { \
152 return fn((float4)V1, (float4)V2); \
153 } \
154 _DXC_DEPRECATED_INT_FN(fn) \
155 constexpr float fn(uint64_t V1, uint64_t V2) { \
156 return fn((float)V1, (float)V2); \
157 } \
158 _DXC_DEPRECATED_INT_FN(fn) \
159 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) { \
160 return fn((float2)V1, (float2)V2); \
161 } \
162 _DXC_DEPRECATED_INT_FN(fn) \
163 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) { \
164 return fn((float3)V1, (float3)V2); \
165 } \
166 _DXC_DEPRECATED_INT_FN(fn) \
167 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) { \
168 return fn((float4)V1, (float4)V2); \
169 }
170
171#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn) \
172 _DXC_DEPRECATED_INT_FN(fn) \
173 constexpr float fn(int V1, int V2, int V3) { \
174 return fn((float)V1, (float)V2, (float)V3); \
175 } \
176 _DXC_DEPRECATED_INT_FN(fn) \
177 constexpr float2 fn(int2 V1, int2 V2, int2 V3) { \
178 return fn((float2)V1, (float2)V2, (float2)V3); \
179 } \
180 _DXC_DEPRECATED_INT_FN(fn) \
181 constexpr float3 fn(int3 V1, int3 V2, int3 V3) { \
182 return fn((float3)V1, (float3)V2, (float3)V3); \
183 } \
184 _DXC_DEPRECATED_INT_FN(fn) \
185 constexpr float4 fn(int4 V1, int4 V2, int4 V3) { \
186 return fn((float4)V1, (float4)V2, (float4)V3); \
187 } \
188 _DXC_DEPRECATED_INT_FN(fn) \
189 constexpr float fn(uint V1, uint V2, uint V3) { \
190 return fn((float)V1, (float)V2, (float)V3); \
191 } \
192 _DXC_DEPRECATED_INT_FN(fn) \
193 constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) { \
194 return fn((float2)V1, (float2)V2, (float2)V3); \
195 } \
196 _DXC_DEPRECATED_INT_FN(fn) \
197 constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) { \
198 return fn((float3)V1, (float3)V2, (float3)V3); \
199 } \
200 _DXC_DEPRECATED_INT_FN(fn) \
201 constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) { \
202 return fn((float4)V1, (float4)V2, (float4)V3); \
203 } \
204 _DXC_DEPRECATED_INT_FN(fn) \
205 constexpr float fn(int64_t V1, int64_t V2, int64_t V3) { \
206 return fn((float)V1, (float)V2, (float)V3); \
207 } \
208 _DXC_DEPRECATED_INT_FN(fn) \
209 constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) { \
210 return fn((float2)V1, (float2)V2, (float2)V3); \
211 } \
212 _DXC_DEPRECATED_INT_FN(fn) \
213 constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) { \
214 return fn((float3)V1, (float3)V2, (float3)V3); \
215 } \
216 _DXC_DEPRECATED_INT_FN(fn) \
217 constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) { \
218 return fn((float4)V1, (float4)V2, (float4)V3); \
219 } \
220 _DXC_DEPRECATED_INT_FN(fn) \
221 constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) { \
222 return fn((float)V1, (float)V2, (float)V3); \
223 } \
224 _DXC_DEPRECATED_INT_FN(fn) \
225 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) { \
226 return fn((float2)V1, (float2)V2, (float2)V3); \
227 } \
228 _DXC_DEPRECATED_INT_FN(fn) \
229 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) { \
230 return fn((float3)V1, (float3)V2, (float3)V3); \
231 } \
232 _DXC_DEPRECATED_INT_FN(fn) \
233 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) { \
234 return fn((float4)V1, (float4)V2, (float4)V3); \
235 }
236
237#define _DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(fn) \
238 template <uint R, uint C> \
239 _DXC_DEPRECATED_64BIT_FN(fn) \
240 constexpr matrix<float, R, C> fn(matrix<double, R, C> V1, \
241 matrix<double, R, C> V2) { \
242 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
243 }
244
245#define _DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(fn) \
246 template <uint R, uint C> \
247 _DXC_DEPRECATED_INT_FN(fn) \
248 constexpr matrix<float, R, C> fn(matrix<int, R, C> V1, \
249 matrix<int, R, C> V2) { \
250 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
251 } \
252 \
253 template <uint R, uint C> \
254 _DXC_DEPRECATED_INT_FN(fn) \
255 constexpr matrix<float, R, C> fn(matrix<uint, R, C> V1, \
256 matrix<uint, R, C> V2) { \
257 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
258 } \
259 \
260 template <uint R, uint C> \
261 _DXC_DEPRECATED_INT_FN(fn) \
262 constexpr matrix<float, R, C> fn(matrix<int64_t, R, C> V1, \
263 matrix<int64_t, R, C> V2) { \
264 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
265 } \
266 \
267 template <uint R, uint C> \
268 _DXC_DEPRECATED_INT_FN(fn) \
269 constexpr matrix<float, R, C> fn(matrix<uint64_t, R, C> V1, \
270 matrix<uint64_t, R, C> V2) { \
271 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
272 }
273
274//===----------------------------------------------------------------------===//
275// acos builtins overloads
276//===----------------------------------------------------------------------===//
277
278_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(acos)
279_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(acos)
280
281//===----------------------------------------------------------------------===//
282// asin builtins overloads
283//===----------------------------------------------------------------------===//
284
285_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(asin)
286_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(asin)
287
288//===----------------------------------------------------------------------===//
289// atan builtins overloads
290//===----------------------------------------------------------------------===//
291
292_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(atan)
293_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(atan)
294
295//===----------------------------------------------------------------------===//
296// atan2 builtins overloads
297//===----------------------------------------------------------------------===//
298
299_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(atan2)
300_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(atan2)
301_DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(atan2)
302_DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(atan2)
303
304//===----------------------------------------------------------------------===//
305// ceil builtins overloads
306//===----------------------------------------------------------------------===//
307
308_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(ceil)
309_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)
310
311//===----------------------------------------------------------------------===//
312// clamp builtins overloads
313//===----------------------------------------------------------------------===//
314
315template <typename T, uint N>
316_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
317constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
318 vector<T, N> p0, vector<T, N> p1, T p2) {
319 return clamp(p0, p1, (vector<T, N>)p2);
320}
321
322template <typename T, uint N>
323_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
324constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
325 vector<T, N> p0, T p1, vector<T, N> p2) {
326 return clamp(p0, (vector<T, N>)p1, p2);
327}
328
329template <typename T, uint N>
330_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
331constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
332 vector<T, N> p0, T p1, T p2) {
333 return clamp(p0, (vector<T, N>)p1, (vector<T, N>)p2);
334}
335
336//===----------------------------------------------------------------------===//
337// cos builtins overloads
338//===----------------------------------------------------------------------===//
339
340_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cos)
341_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cos)
342
343//===----------------------------------------------------------------------===//
344// cosh builtins overloads
345//===----------------------------------------------------------------------===//
346
347_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cosh)
348_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cosh)
349
350//===----------------------------------------------------------------------===//
351// degrees builtins overloads
352//===----------------------------------------------------------------------===//
353
354_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(degrees)
355_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(degrees)
356
357//===----------------------------------------------------------------------===//
358// exp builtins overloads
359//===----------------------------------------------------------------------===//
360
361_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp)
362_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp)
363
364//===----------------------------------------------------------------------===//
365// exp2 builtins overloads
366//===----------------------------------------------------------------------===//
367
368_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp2)
369_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp2)
370
371//===----------------------------------------------------------------------===//
372// floor builtins overloads
373//===----------------------------------------------------------------------===//
374
375_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(floor)
376_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(floor)
377
378//===----------------------------------------------------------------------===//
379// frac builtins overloads
380//===----------------------------------------------------------------------===//
381
382_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(frac)
383_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
384
385//===----------------------------------------------------------------------===//
386// isfinite builtins overloads
387//===----------------------------------------------------------------------===//
388
389_DXC_DEPRECATED_64BIT_FN(isfinite)
390constexpr bool isfinite(double V) { return isfinite((float)V); }
391_DXC_DEPRECATED_64BIT_FN(isfinite)
392constexpr bool2 isfinite(double2 V) { return isfinite((float2)V); }
393_DXC_DEPRECATED_64BIT_FN(isfinite)
394constexpr bool3 isfinite(double3 V) { return isfinite((float3)V); }
395_DXC_DEPRECATED_64BIT_FN(isfinite)
396constexpr bool4 isfinite(double4 V) { return isfinite((float4)V); }
397_DXC_DEPRECATED_64BIT_FN(isfinite)
398constexpr bool1x2 isfinite(double1x2 V) { return isfinite((float1x2)V); }
399_DXC_DEPRECATED_64BIT_FN(isfinite)
400constexpr bool1x3 isfinite(double1x3 V) { return isfinite((float1x3)V); }
401_DXC_DEPRECATED_64BIT_FN(isfinite)
402constexpr bool1x4 isfinite(double1x4 V) { return isfinite((float1x4)V); }
403_DXC_DEPRECATED_64BIT_FN(isfinite)
404constexpr bool2x1 isfinite(double2x1 V) { return isfinite((float2x1)V); }
405_DXC_DEPRECATED_64BIT_FN(isfinite)
406constexpr bool2x2 isfinite(double2x2 V) { return isfinite((float2x2)V); }
407_DXC_DEPRECATED_64BIT_FN(isfinite)
408constexpr bool2x3 isfinite(double2x3 V) { return isfinite((float2x3)V); }
409_DXC_DEPRECATED_64BIT_FN(isfinite)
410constexpr bool2x4 isfinite(double2x4 V) { return isfinite((float2x4)V); }
411_DXC_DEPRECATED_64BIT_FN(isfinite)
412constexpr bool3x1 isfinite(double3x1 V) { return isfinite((float3x1)V); }
413_DXC_DEPRECATED_64BIT_FN(isfinite)
414constexpr bool3x2 isfinite(double3x2 V) { return isfinite((float3x2)V); }
415_DXC_DEPRECATED_64BIT_FN(isfinite)
416constexpr bool3x3 isfinite(double3x3 V) { return isfinite((float3x3)V); }
417_DXC_DEPRECATED_64BIT_FN(isfinite)
418constexpr bool3x4 isfinite(double3x4 V) { return isfinite((float3x4)V); }
419_DXC_DEPRECATED_64BIT_FN(isfinite)
420constexpr bool4x1 isfinite(double4x1 V) { return isfinite((float4x1)V); }
421_DXC_DEPRECATED_64BIT_FN(isfinite)
422constexpr bool4x2 isfinite(double4x2 V) { return isfinite((float4x2)V); }
423_DXC_DEPRECATED_64BIT_FN(isfinite)
424constexpr bool4x3 isfinite(double4x3 V) { return isfinite((float4x3)V); }
425_DXC_DEPRECATED_64BIT_FN(isfinite)
426constexpr bool4x4 isfinite(double4x4 V) { return isfinite((float4x4)V); }
427
428//===----------------------------------------------------------------------===//
429// isinf builtins overloads
430//===----------------------------------------------------------------------===//
431
432_DXC_DEPRECATED_64BIT_FN(isinf)
433constexpr bool isinf(double V) { return isinf((float)V); }
434_DXC_DEPRECATED_64BIT_FN(isinf)
435constexpr bool2 isinf(double2 V) { return isinf((float2)V); }
436_DXC_DEPRECATED_64BIT_FN(isinf)
437constexpr bool3 isinf(double3 V) { return isinf((float3)V); }
438_DXC_DEPRECATED_64BIT_FN(isinf)
439constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
440_DXC_DEPRECATED_64BIT_FN(isinf)
441constexpr bool1x2 isinf(double1x2 V) { return isinf((float1x2)V); }
442_DXC_DEPRECATED_64BIT_FN(isinf)
443constexpr bool1x3 isinf(double1x3 V) { return isinf((float1x3)V); }
444_DXC_DEPRECATED_64BIT_FN(isinf)
445constexpr bool1x4 isinf(double1x4 V) { return isinf((float1x4)V); }
446_DXC_DEPRECATED_64BIT_FN(isinf)
447constexpr bool2x1 isinf(double2x1 V) { return isinf((float2x1)V); }
448_DXC_DEPRECATED_64BIT_FN(isinf)
449constexpr bool2x2 isinf(double2x2 V) { return isinf((float2x2)V); }
450_DXC_DEPRECATED_64BIT_FN(isinf)
451constexpr bool2x3 isinf(double2x3 V) { return isinf((float2x3)V); }
452_DXC_DEPRECATED_64BIT_FN(isinf)
453constexpr bool2x4 isinf(double2x4 V) { return isinf((float2x4)V); }
454_DXC_DEPRECATED_64BIT_FN(isinf)
455constexpr bool3x1 isinf(double3x1 V) { return isinf((float3x1)V); }
456_DXC_DEPRECATED_64BIT_FN(isinf)
457constexpr bool3x2 isinf(double3x2 V) { return isinf((float3x2)V); }
458_DXC_DEPRECATED_64BIT_FN(isinf)
459constexpr bool3x3 isinf(double3x3 V) { return isinf((float3x3)V); }
460_DXC_DEPRECATED_64BIT_FN(isinf)
461constexpr bool3x4 isinf(double3x4 V) { return isinf((float3x4)V); }
462_DXC_DEPRECATED_64BIT_FN(isinf)
463constexpr bool4x1 isinf(double4x1 V) { return isinf((float4x1)V); }
464_DXC_DEPRECATED_64BIT_FN(isinf)
465constexpr bool4x2 isinf(double4x2 V) { return isinf((float4x2)V); }
466_DXC_DEPRECATED_64BIT_FN(isinf)
467constexpr bool4x3 isinf(double4x3 V) { return isinf((float4x3)V); }
468_DXC_DEPRECATED_64BIT_FN(isinf)
469constexpr bool4x4 isinf(double4x4 V) { return isinf((float4x4)V); }
470
471//===----------------------------------------------------------------------===//
472// isnan builtins overloads
473//===----------------------------------------------------------------------===//
474
475_DXC_DEPRECATED_64BIT_FN(isnan)
476constexpr bool isnan(double V) { return isnan((float)V); }
477_DXC_DEPRECATED_64BIT_FN(isnan)
478constexpr bool2 isnan(double2 V) { return isnan((float2)V); }
479_DXC_DEPRECATED_64BIT_FN(isnan)
480constexpr bool3 isnan(double3 V) { return isnan((float3)V); }
481_DXC_DEPRECATED_64BIT_FN(isnan)
482constexpr bool4 isnan(double4 V) { return isnan((float4)V); }
483_DXC_DEPRECATED_64BIT_FN(isnan)
484constexpr bool1x2 isnan(double1x2 V) { return isnan((float1x2)V); }
485_DXC_DEPRECATED_64BIT_FN(isnan)
486constexpr bool1x3 isnan(double1x3 V) { return isnan((float1x3)V); }
487_DXC_DEPRECATED_64BIT_FN(isnan)
488constexpr bool1x4 isnan(double1x4 V) { return isnan((float1x4)V); }
489_DXC_DEPRECATED_64BIT_FN(isnan)
490constexpr bool2x1 isnan(double2x1 V) { return isnan((float2x1)V); }
491_DXC_DEPRECATED_64BIT_FN(isnan)
492constexpr bool2x2 isnan(double2x2 V) { return isnan((float2x2)V); }
493_DXC_DEPRECATED_64BIT_FN(isnan)
494constexpr bool2x3 isnan(double2x3 V) { return isnan((float2x3)V); }
495_DXC_DEPRECATED_64BIT_FN(isnan)
496constexpr bool2x4 isnan(double2x4 V) { return isnan((float2x4)V); }
497_DXC_DEPRECATED_64BIT_FN(isnan)
498constexpr bool3x1 isnan(double3x1 V) { return isnan((float3x1)V); }
499_DXC_DEPRECATED_64BIT_FN(isnan)
500constexpr bool3x2 isnan(double3x2 V) { return isnan((float3x2)V); }
501_DXC_DEPRECATED_64BIT_FN(isnan)
502constexpr bool3x3 isnan(double3x3 V) { return isnan((float3x3)V); }
503_DXC_DEPRECATED_64BIT_FN(isnan)
504constexpr bool3x4 isnan(double3x4 V) { return isnan((float3x4)V); }
505_DXC_DEPRECATED_64BIT_FN(isnan)
506constexpr bool4x1 isnan(double4x1 V) { return isnan((float4x1)V); }
507_DXC_DEPRECATED_64BIT_FN(isnan)
508constexpr bool4x2 isnan(double4x2 V) { return isnan((float4x2)V); }
509_DXC_DEPRECATED_64BIT_FN(isnan)
510constexpr bool4x3 isnan(double4x3 V) { return isnan((float4x3)V); }
511_DXC_DEPRECATED_64BIT_FN(isnan)
512constexpr bool4x4 isnan(double4x4 V) { return isnan((float4x4)V); }
513
514//===----------------------------------------------------------------------===//
515// lerp builtins overloads
516//===----------------------------------------------------------------------===//
517
518template <typename T, uint N>
519_DXC_DEPRECATED_VEC_SCALAR_FN(lerp)
520constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> lerp(
521 vector<T, N> x, vector<T, N> y, T s) {
522 return lerp(x, y, (vector<T, N>)s);
523}
524
525_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(lerp)
526_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(lerp)
527
528//===----------------------------------------------------------------------===//
529// log builtins overloads
530//===----------------------------------------------------------------------===//
531
532_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log)
533_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log)
534
535//===----------------------------------------------------------------------===//
536// log10 builtins overloads
537//===----------------------------------------------------------------------===//
538
539_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log10)
540_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log10)
541
542//===----------------------------------------------------------------------===//
543// log2 builtins overloads
544//===----------------------------------------------------------------------===//
545
546_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log2)
547_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)
548
549//===----------------------------------------------------------------------===//
550// max builtins overloads
551//===----------------------------------------------------------------------===//
552
553template <typename T, uint N>
554_DXC_DEPRECATED_VEC_SCALAR_FN(max)
555constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
556 vector<T, N> p0, T p1) {
557 return max(p0, (vector<T, N>)p1);
558}
559
560template <typename T, uint N>
561_DXC_DEPRECATED_VEC_SCALAR_FN(max)
562constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
563 T p0, vector<T, N> p1) {
564 return max((vector<T, N>)p0, p1);
565}
566
567_DXC_DEPRECATED_SCALAR_FN(float, int, max)
568constexpr float max(float p0, int p1) { return max(p0, (float)p1); }
569
570_DXC_DEPRECATED_SCALAR_FN(int, float, max)
571constexpr float max(int p0, float p1) { return max((float)p0, p1); }
572
573//===----------------------------------------------------------------------===//
574// min builtins overloads
575//===----------------------------------------------------------------------===//
576
577template <typename T, uint N>
578_DXC_DEPRECATED_VEC_SCALAR_FN(min)
579constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(
580 vector<T, N> p0, T p1) {
581 return min(p0, (vector<T, N>)p1);
582}
583
584template <typename T, uint N>
585_DXC_DEPRECATED_VEC_SCALAR_FN(min)
586constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(
587 T p0, vector<T, N> p1) {
588 return min((vector<T, N>)p0, p1);
589}
590
591_DXC_DEPRECATED_SCALAR_FN(float, int, min)
592constexpr float min(float p0, int p1) { return min(p0, (float)p1); }
593
594_DXC_DEPRECATED_SCALAR_FN(int, float, min)
595constexpr float min(int p0, float p1) { return min((float)p0, p1); }
596
597//===----------------------------------------------------------------------===//
598// normalize builtins overloads
599//===----------------------------------------------------------------------===//
600
601_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(normalize)
602_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(normalize)
603
604//===----------------------------------------------------------------------===//
605// pow builtins overloads
606//===----------------------------------------------------------------------===//
607
608_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(pow)
609_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(pow)
610_DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(pow)
611_DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(pow)
612
613//===----------------------------------------------------------------------===//
614// rsqrt builtins overloads
615//===----------------------------------------------------------------------===//
616
617_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(rsqrt)
618_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(rsqrt)
619
620//===----------------------------------------------------------------------===//
621// round builtins overloads
622//===----------------------------------------------------------------------===//
623
624_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(round)
625_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(round)
626
627//===----------------------------------------------------------------------===//
628// sin builtins overloads
629//===----------------------------------------------------------------------===//
630
631_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sin)
632_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sin)
633
634//===----------------------------------------------------------------------===//
635// sinh builtins overloads
636//===----------------------------------------------------------------------===//
637
638_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sinh)
639_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sinh)
640
641//===----------------------------------------------------------------------===//
642// sqrt builtins overloads
643//===----------------------------------------------------------------------===//
644
645_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sqrt)
646_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sqrt)
647
648//===----------------------------------------------------------------------===//
649// step builtins overloads
650//===----------------------------------------------------------------------===//
651
652_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(step)
653_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(step)
654
655//===----------------------------------------------------------------------===//
656// tan builtins overloads
657//===----------------------------------------------------------------------===//
658
659_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tan)
660_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tan)
661
662//===----------------------------------------------------------------------===//
663// tanh builtins overloads
664//===----------------------------------------------------------------------===//
665
666_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tanh)
667_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tanh)
668
669//===----------------------------------------------------------------------===//
670// trunc builtins overloads
671//===----------------------------------------------------------------------===//
672
673_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(trunc)
674_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(trunc)
675
676//===----------------------------------------------------------------------===//
677// radians builtins overloads
678//===----------------------------------------------------------------------===//
679
680_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(radians)
681_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(radians)
682
683} // namespace hlsl
684#endif // _HLSL_COMPAT_OVERLOADS_H_
V
#define V(N, I)
Definition ASTContext.h:3868
isnan
__DEVICE__ bool isnan(float __x)
Test for a NaN.
Definition __clang_cuda_cmath.h:108
isfinite
__DEVICE__ bool isfinite(float __x)
Test for finite value.
Definition __clang_cuda_cmath.h:103
isinf
__DEVICE__ bool isinf(float __x)
Test for infinity value (+ve or -ve) .
Definition __clang_cuda_cmath.h:101
min
__DEVICE__ int min(int __a, int __b)
Definition __clang_cuda_math.h:201
max
__DEVICE__ int max(int __a, int __b)
Definition __clang_cuda_math.h:200
rsqrt
__DEVICE__ double rsqrt(double __a)
Definition __clang_cuda_math.h:279
_DXC_DEPRECATED_64BIT_FN
#define _DXC_DEPRECATED_64BIT_FN(fn)
Definition hlsl_compat_overloads.h:19
_DXC_DEPRECATED_VEC_SCALAR_FN
#define _DXC_DEPRECATED_VEC_SCALAR_FN(fn)
Definition hlsl_compat_overloads.h:27
_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:45
_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:171
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:35
_DXC_DEPRECATED_SCALAR_FN
#define _DXC_DEPRECATED_SCALAR_FN(ty1, ty2, fn)
Definition hlsl_compat_overloads.h:31
_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:63
_DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS
#define _DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:245
_DXC_COMPAT_UNARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:81
_DXC_COMPAT_BINARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:115
_DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS
#define _DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:237
hlsl::__detail
Definition hlsl_detail.h:14
hlsl::double4x3
matrix< double, 4, 3 > double4x3
Definition hlsl_basic_types.h:313
hlsl::double3x3
matrix< double, 3, 3 > double3x3
Definition hlsl_basic_types.h:309
hlsl::float2x1
matrix< float, 2, 1 > float2x1
Definition hlsl_basic_types.h:287
hlsl::float4x4
matrix< float, 4, 4 > float4x4
Definition hlsl_basic_types.h:298
hlsl::float3x1
matrix< float, 3, 1 > float3x1
Definition hlsl_basic_types.h:291
hlsl::double2x3
matrix< double, 2, 3 > double2x3
Definition hlsl_basic_types.h:305
hlsl::bool2x1
matrix< bool, 2, 1 > bool2x1
Definition hlsl_basic_types.h:157
hlsl::isfinite
constexpr bool isfinite(double V)
Definition hlsl_compat_overloads.h:390
hlsl::double3x2
matrix< double, 3, 2 > double3x2
Definition hlsl_basic_types.h:308
hlsl::float1x4
matrix< float, 1, 4 > float1x4
Definition hlsl_basic_types.h:286
hlsl::float3x2
matrix< float, 3, 2 > float3x2
Definition hlsl_basic_types.h:292
hlsl::float1x3
matrix< float, 1, 3 > float1x3
Definition hlsl_basic_types.h:285
hlsl::float3x4
matrix< float, 3, 4 > float3x4
Definition hlsl_basic_types.h:294
hlsl::bool1x4
matrix< bool, 1, 4 > bool1x4
Definition hlsl_basic_types.h:156
hlsl::bool4x1
matrix< bool, 4, 1 > bool4x1
Definition hlsl_basic_types.h:165
hlsl::isinf
constexpr bool isinf(double V)
Definition hlsl_compat_overloads.h:433
hlsl::float4
vector< float, 4 > float4
Definition hlsl_basic_types.h:96
hlsl::bool2x3
matrix< bool, 2, 3 > bool2x3
Definition hlsl_basic_types.h:159
hlsl::bool2x2
matrix< bool, 2, 2 > bool2x2
Definition hlsl_basic_types.h:158
hlsl::double4x2
matrix< double, 4, 2 > double4x2
Definition hlsl_basic_types.h:312
hlsl::bool2x4
matrix< bool, 2, 4 > bool2x4
Definition hlsl_basic_types.h:160
hlsl::bool3x1
matrix< bool, 3, 1 > bool3x1
Definition hlsl_basic_types.h:161
hlsl::bool3x4
matrix< bool, 3, 4 > bool3x4
Definition hlsl_basic_types.h:164
hlsl::double2x1
matrix< double, 2, 1 > double2x1
Definition hlsl_basic_types.h:303
hlsl::bool3x2
matrix< bool, 3, 2 > bool3x2
Definition hlsl_basic_types.h:162
hlsl::double2x2
matrix< double, 2, 2 > double2x2
Definition hlsl_basic_types.h:304
hlsl::bool4
vector< bool, 4 > bool4
Definition hlsl_basic_types.h:63
hlsl::double3x1
matrix< double, 3, 1 > double3x1
Definition hlsl_basic_types.h:307
hlsl::double1x2
matrix< double, 1, 2 > double1x2
Definition hlsl_basic_types.h:300
hlsl::lerp
constexpr __detail::enable_if_t<(N > 1 &&N<=4), vector< T, N > > lerp(vector< T, N > x, vector< T, N > y, T s)
Definition hlsl_compat_overloads.h:520
hlsl::bool3
vector< bool, 3 > bool3
Definition hlsl_basic_types.h:62
hlsl::bool1x2
matrix< bool, 1, 2 > bool1x2
Definition hlsl_basic_types.h:154
hlsl::float4x2
matrix< float, 4, 2 > float4x2
Definition hlsl_basic_types.h:296
hlsl::double4x1
matrix< double, 4, 1 > double4x1
Definition hlsl_basic_types.h:311
hlsl::float1x2
matrix< float, 1, 2 > float1x2
Definition hlsl_basic_types.h:284
hlsl::double3
vector< double, 3 > double3
Definition hlsl_basic_types.h:99
hlsl::float2
vector< float, 2 > float2
Definition hlsl_basic_types.h:94
hlsl::max
constexpr __detail::enable_if_t<(N > 1 &&N<=4), vector< T, N > > max(vector< T, N > p0, T p1)
Definition hlsl_compat_overloads.h:555
hlsl::float3
vector< float, 3 > float3
Definition hlsl_basic_types.h:95
hlsl::bool1x3
matrix< bool, 1, 3 > bool1x3
Definition hlsl_basic_types.h:155
hlsl::double2x4
matrix< double, 2, 4 > double2x4
Definition hlsl_basic_types.h:306
hlsl::min
constexpr __detail::enable_if_t<(N > 1 &&N<=4), vector< T, N > > min(vector< T, N > p0, T p1)
Definition hlsl_compat_overloads.h:579
hlsl::double4
vector< double, 4 > double4
Definition hlsl_basic_types.h:100
hlsl::double2
vector< double, 2 > double2
Definition hlsl_basic_types.h:98
hlsl::bool2
vector< bool, 2 > bool2
Definition hlsl_basic_types.h:61
hlsl::float2x3
matrix< float, 2, 3 > float2x3
Definition hlsl_basic_types.h:289
hlsl::clamp
constexpr __detail::enable_if_t<(N > 1 &&N<=4), vector< T, N > > clamp(vector< T, N > p0, vector< T, N > p1, T p2)
Definition hlsl_compat_overloads.h:317
hlsl::double1x3
matrix< double, 1, 3 > double1x3
Definition hlsl_basic_types.h:301
hlsl::bool3x3
matrix< bool, 3, 3 > bool3x3
Definition hlsl_basic_types.h:163
hlsl::double4x4
matrix< double, 4, 4 > double4x4
Definition hlsl_basic_types.h:314
hlsl::float2x4
matrix< float, 2, 4 > float2x4
Definition hlsl_basic_types.h:290
hlsl::float4x3
matrix< float, 4, 3 > float4x3
Definition hlsl_basic_types.h:297
hlsl::bool4x2
matrix< bool, 4, 2 > bool4x2
Definition hlsl_basic_types.h:166
hlsl::float3x3
matrix< float, 3, 3 > float3x3
Definition hlsl_basic_types.h:293
hlsl::double3x4
matrix< double, 3, 4 > double3x4
Definition hlsl_basic_types.h:310
hlsl::bool4x4
matrix< bool, 4, 4 > bool4x4
Definition hlsl_basic_types.h:168
hlsl::bool4x3
matrix< bool, 4, 3 > bool4x3
Definition hlsl_basic_types.h:167
hlsl::float4x1
matrix< float, 4, 1 > float4x1
Definition hlsl_basic_types.h:295
hlsl::float2x2
matrix< float, 2, 2 > float2x2
Definition hlsl_basic_types.h:288
hlsl::double1x4
matrix< double, 1, 4 > double1x4
Definition hlsl_basic_types.h:302
hlsl::isnan
constexpr bool isnan(double V)
Definition hlsl_compat_overloads.h:476
step
float __ovld __cnfn step(float, float)
Returns 0.0 if x < edge, otherwise it returns 1.0.
radians
float __ovld __cnfn radians(float)
Converts degrees to radians, i.e.
degrees
float __ovld __cnfn degrees(float)
Converts radians to degrees, i.e.
clamp
char __ovld __cnfn clamp(char, char, char)
Returns min(max(x, minval), maxval).
normalize
float __ovld __cnfn normalize(float)
Returns a vector in the same direction as p but with a length of 1.
sinh
#define sinh(__x)
Definition tgmath.h:373
asin
#define asin(__x)
Definition tgmath.h:112
sqrt
#define sqrt(__x)
Definition tgmath.h:520
acos
#define acos(__x)
Definition tgmath.h:83
exp
#define exp(__x)
Definition tgmath.h:431
atan2
#define atan2(__x, __y)
Definition tgmath.h:566
exp2
#define exp2(__x)
Definition tgmath.h:670
sin
#define sin(__x)
Definition tgmath.h:286
log2
#define log2(__x)
Definition tgmath.h:970
cosh
#define cosh(__x)
Definition tgmath.h:344
trunc
#define trunc(__x)
Definition tgmath.h:1216
round
#define round(__x)
Definition tgmath.h:1148
tan
#define tan(__x)
Definition tgmath.h:315
cos
#define cos(__x)
Definition tgmath.h:257
log10
#define log10(__x)
Definition tgmath.h:936
pow
#define pow(__x, __y)
Definition tgmath.h:490
tanh
#define tanh(__x)
Definition tgmath.h:402
atan
#define atan(__x)
Definition tgmath.h:141
floor
#define floor(__x)
Definition tgmath.h:722
ceil
#define ceil(__x)
Definition tgmath.h:601
log
#define log(__x)
Definition tgmath.h:460
Generated on for clang by doxygen 1.14.0