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_COMPAT_UNARY_DOUBLE_OVERLOADS(fn) \
32 _DXC_DEPRECATED_64BIT_FN(fn) \
33 constexpr float fn(double V) { return fn((float)V); } \
34 _DXC_DEPRECATED_64BIT_FN(fn) \
35 constexpr float2 fn(double2 V) { return fn((float2)V); } \
36 _DXC_DEPRECATED_64BIT_FN(fn) \
37 constexpr float3 fn(double3 V) { return fn((float3)V); } \
38 _DXC_DEPRECATED_64BIT_FN(fn) \
39 constexpr float4 fn(double4 V) { return fn((float4)V); }
40
41#define _DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(fn) \
42 _DXC_DEPRECATED_64BIT_FN(fn) \
43 constexpr float fn(double V1, double V2) { \
44 return fn((float)V1, (float)V2); \
45 } \
46 _DXC_DEPRECATED_64BIT_FN(fn) \
47 constexpr float2 fn(double2 V1, double2 V2) { \
48 return fn((float2)V1, (float2)V2); \
49 } \
50 _DXC_DEPRECATED_64BIT_FN(fn) \
51 constexpr float3 fn(double3 V1, double3 V2) { \
52 return fn((float3)V1, (float3)V2); \
53 } \
54 _DXC_DEPRECATED_64BIT_FN(fn) \
55 constexpr float4 fn(double4 V1, double4 V2) { \
56 return fn((float4)V1, (float4)V2); \
57 }
58
59#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn) \
60 _DXC_DEPRECATED_64BIT_FN(fn) \
61 constexpr float fn(double V1, double V2, double V3) { \
62 return fn((float)V1, (float)V2, (float)V3); \
63 } \
64 _DXC_DEPRECATED_64BIT_FN(fn) \
65 constexpr float2 fn(double2 V1, double2 V2, double2 V3) { \
66 return fn((float2)V1, (float2)V2, (float2)V3); \
67 } \
68 _DXC_DEPRECATED_64BIT_FN(fn) \
69 constexpr float3 fn(double3 V1, double3 V2, double3 V3) { \
70 return fn((float3)V1, (float3)V2, (float3)V3); \
71 } \
72 _DXC_DEPRECATED_64BIT_FN(fn) \
73 constexpr float4 fn(double4 V1, double4 V2, double4 V3) { \
74 return fn((float4)V1, (float4)V2, (float4)V3); \
75 }
76
77#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn) \
78 _DXC_DEPRECATED_INT_FN(fn) \
79 constexpr float fn(int V) { return fn((float)V); } \
80 _DXC_DEPRECATED_INT_FN(fn) \
81 constexpr float2 fn(int2 V) { return fn((float2)V); } \
82 _DXC_DEPRECATED_INT_FN(fn) \
83 constexpr float3 fn(int3 V) { return fn((float3)V); } \
84 _DXC_DEPRECATED_INT_FN(fn) \
85 constexpr float4 fn(int4 V) { return fn((float4)V); } \
86 _DXC_DEPRECATED_INT_FN(fn) \
87 constexpr float fn(uint V) { return fn((float)V); } \
88 _DXC_DEPRECATED_INT_FN(fn) \
89 constexpr float2 fn(uint2 V) { return fn((float2)V); } \
90 _DXC_DEPRECATED_INT_FN(fn) \
91 constexpr float3 fn(uint3 V) { return fn((float3)V); } \
92 _DXC_DEPRECATED_INT_FN(fn) \
93 constexpr float4 fn(uint4 V) { return fn((float4)V); } \
94 _DXC_DEPRECATED_INT_FN(fn) \
95 constexpr float fn(int64_t V) { return fn((float)V); } \
96 _DXC_DEPRECATED_INT_FN(fn) \
97 constexpr float2 fn(int64_t2 V) { return fn((float2)V); } \
98 _DXC_DEPRECATED_INT_FN(fn) \
99 constexpr float3 fn(int64_t3 V) { return fn((float3)V); } \
100 _DXC_DEPRECATED_INT_FN(fn) \
101 constexpr float4 fn(int64_t4 V) { return fn((float4)V); } \
102 _DXC_DEPRECATED_INT_FN(fn) \
103 constexpr float fn(uint64_t V) { return fn((float)V); } \
104 _DXC_DEPRECATED_INT_FN(fn) \
105 constexpr float2 fn(uint64_t2 V) { return fn((float2)V); } \
106 _DXC_DEPRECATED_INT_FN(fn) \
107 constexpr float3 fn(uint64_t3 V) { return fn((float3)V); } \
108 _DXC_DEPRECATED_INT_FN(fn) \
109 constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }
110
111#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn) \
112 _DXC_DEPRECATED_INT_FN(fn) \
113 constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); } \
114 _DXC_DEPRECATED_INT_FN(fn) \
115 constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \
116 _DXC_DEPRECATED_INT_FN(fn) \
117 constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \
118 _DXC_DEPRECATED_INT_FN(fn) \
119 constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \
120 _DXC_DEPRECATED_INT_FN(fn) \
121 constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); } \
122 _DXC_DEPRECATED_INT_FN(fn) \
123 constexpr float2 fn(uint2 V1, uint2 V2) { \
124 return fn((float2)V1, (float2)V2); \
125 } \
126 _DXC_DEPRECATED_INT_FN(fn) \
127 constexpr float3 fn(uint3 V1, uint3 V2) { \
128 return fn((float3)V1, (float3)V2); \
129 } \
130 _DXC_DEPRECATED_INT_FN(fn) \
131 constexpr float4 fn(uint4 V1, uint4 V2) { \
132 return fn((float4)V1, (float4)V2); \
133 } \
134 _DXC_DEPRECATED_INT_FN(fn) \
135 constexpr float fn(int64_t V1, int64_t V2) { \
136 return fn((float)V1, (float)V2); \
137 } \
138 _DXC_DEPRECATED_INT_FN(fn) \
139 constexpr float2 fn(int64_t2 V1, int64_t2 V2) { \
140 return fn((float2)V1, (float2)V2); \
141 } \
142 _DXC_DEPRECATED_INT_FN(fn) \
143 constexpr float3 fn(int64_t3 V1, int64_t3 V2) { \
144 return fn((float3)V1, (float3)V2); \
145 } \
146 _DXC_DEPRECATED_INT_FN(fn) \
147 constexpr float4 fn(int64_t4 V1, int64_t4 V2) { \
148 return fn((float4)V1, (float4)V2); \
149 } \
150 _DXC_DEPRECATED_INT_FN(fn) \
151 constexpr float fn(uint64_t V1, uint64_t V2) { \
152 return fn((float)V1, (float)V2); \
153 } \
154 _DXC_DEPRECATED_INT_FN(fn) \
155 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) { \
156 return fn((float2)V1, (float2)V2); \
157 } \
158 _DXC_DEPRECATED_INT_FN(fn) \
159 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) { \
160 return fn((float3)V1, (float3)V2); \
161 } \
162 _DXC_DEPRECATED_INT_FN(fn) \
163 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) { \
164 return fn((float4)V1, (float4)V2); \
165 }
166
167#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn) \
168 _DXC_DEPRECATED_INT_FN(fn) \
169 constexpr float fn(int V1, int V2, int V3) { \
170 return fn((float)V1, (float)V2, (float)V3); \
171 } \
172 _DXC_DEPRECATED_INT_FN(fn) \
173 constexpr float2 fn(int2 V1, int2 V2, int2 V3) { \
174 return fn((float2)V1, (float2)V2, (float2)V3); \
175 } \
176 _DXC_DEPRECATED_INT_FN(fn) \
177 constexpr float3 fn(int3 V1, int3 V2, int3 V3) { \
178 return fn((float3)V1, (float3)V2, (float3)V3); \
179 } \
180 _DXC_DEPRECATED_INT_FN(fn) \
181 constexpr float4 fn(int4 V1, int4 V2, int4 V3) { \
182 return fn((float4)V1, (float4)V2, (float4)V3); \
183 } \
184 _DXC_DEPRECATED_INT_FN(fn) \
185 constexpr float fn(uint V1, uint V2, uint V3) { \
186 return fn((float)V1, (float)V2, (float)V3); \
187 } \
188 _DXC_DEPRECATED_INT_FN(fn) \
189 constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) { \
190 return fn((float2)V1, (float2)V2, (float2)V3); \
191 } \
192 _DXC_DEPRECATED_INT_FN(fn) \
193 constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) { \
194 return fn((float3)V1, (float3)V2, (float3)V3); \
195 } \
196 _DXC_DEPRECATED_INT_FN(fn) \
197 constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) { \
198 return fn((float4)V1, (float4)V2, (float4)V3); \
199 } \
200 _DXC_DEPRECATED_INT_FN(fn) \
201 constexpr float fn(int64_t V1, int64_t V2, int64_t V3) { \
202 return fn((float)V1, (float)V2, (float)V3); \
203 } \
204 _DXC_DEPRECATED_INT_FN(fn) \
205 constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) { \
206 return fn((float2)V1, (float2)V2, (float2)V3); \
207 } \
208 _DXC_DEPRECATED_INT_FN(fn) \
209 constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) { \
210 return fn((float3)V1, (float3)V2, (float3)V3); \
211 } \
212 _DXC_DEPRECATED_INT_FN(fn) \
213 constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) { \
214 return fn((float4)V1, (float4)V2, (float4)V3); \
215 } \
216 _DXC_DEPRECATED_INT_FN(fn) \
217 constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) { \
218 return fn((float)V1, (float)V2, (float)V3); \
219 } \
220 _DXC_DEPRECATED_INT_FN(fn) \
221 constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) { \
222 return fn((float2)V1, (float2)V2, (float2)V3); \
223 } \
224 _DXC_DEPRECATED_INT_FN(fn) \
225 constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) { \
226 return fn((float3)V1, (float3)V2, (float3)V3); \
227 } \
228 _DXC_DEPRECATED_INT_FN(fn) \
229 constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) { \
230 return fn((float4)V1, (float4)V2, (float4)V3); \
231 }
232
233#define _DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(fn) \
234 template <uint R, uint C> \
235 _DXC_DEPRECATED_64BIT_FN(fn) \
236 constexpr matrix<float, R, C> fn(matrix<double, R, C> V1, \
237 matrix<double, R, C> V2) { \
238 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
239 }
240
241#define _DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(fn) \
242 template <uint R, uint C> \
243 _DXC_DEPRECATED_INT_FN(fn) \
244 constexpr matrix<float, R, C> fn(matrix<int, R, C> V1, \
245 matrix<int, R, C> V2) { \
246 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
247 } \
248 \
249 template <uint R, uint C> \
250 _DXC_DEPRECATED_INT_FN(fn) \
251 constexpr matrix<float, R, C> fn(matrix<uint, R, C> V1, \
252 matrix<uint, R, C> V2) { \
253 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
254 } \
255 \
256 template <uint R, uint C> \
257 _DXC_DEPRECATED_INT_FN(fn) \
258 constexpr matrix<float, R, C> fn(matrix<int64_t, R, C> V1, \
259 matrix<int64_t, R, C> V2) { \
260 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
261 } \
262 \
263 template <uint R, uint C> \
264 _DXC_DEPRECATED_INT_FN(fn) \
265 constexpr matrix<float, R, C> fn(matrix<uint64_t, R, C> V1, \
266 matrix<uint64_t, R, C> V2) { \
267 return fn((matrix<float, R, C>)V1, (matrix<float, R, C>)V2); \
268 }
269
270//===----------------------------------------------------------------------===//
271// acos builtins overloads
272//===----------------------------------------------------------------------===//
273
274_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(acos)
275_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(acos)
276
277//===----------------------------------------------------------------------===//
278// asin builtins overloads
279//===----------------------------------------------------------------------===//
280
281_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(asin)
282_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(asin)
283
284//===----------------------------------------------------------------------===//
285// atan builtins overloads
286//===----------------------------------------------------------------------===//
287
288_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(atan)
289_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(atan)
290
291//===----------------------------------------------------------------------===//
292// atan2 builtins overloads
293//===----------------------------------------------------------------------===//
294
295_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(atan2)
296_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(atan2)
297_DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(atan2)
298_DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(atan2)
299
300//===----------------------------------------------------------------------===//
301// ceil builtins overloads
302//===----------------------------------------------------------------------===//
303
304_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(ceil)
305_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)
306
307//===----------------------------------------------------------------------===//
308// clamp builtins overloads
309//===----------------------------------------------------------------------===//
310
311template <typename T, uint N>
312_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
313constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
314 vector<T, N> p0, vector<T, N> p1, T p2) {
315 return clamp(p0, p1, (vector<T, N>)p2);
316}
317
318template <typename T, uint N>
319_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
320constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
321 vector<T, N> p0, T p1, vector<T, N> p2) {
322 return clamp(p0, (vector<T, N>)p1, p2);
323}
324
325template <typename T, uint N>
326_DXC_DEPRECATED_VEC_SCALAR_FN(clamp)
327constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> clamp(
328 vector<T, N> p0, T p1, T p2) {
329 return clamp(p0, (vector<T, N>)p1, (vector<T, N>)p2);
330}
331
332//===----------------------------------------------------------------------===//
333// cos builtins overloads
334//===----------------------------------------------------------------------===//
335
336_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cos)
337_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cos)
338
339//===----------------------------------------------------------------------===//
340// cosh builtins overloads
341//===----------------------------------------------------------------------===//
342
343_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cosh)
344_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cosh)
345
346//===----------------------------------------------------------------------===//
347// degrees builtins overloads
348//===----------------------------------------------------------------------===//
349
350_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(degrees)
351_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(degrees)
352
353//===----------------------------------------------------------------------===//
354// exp builtins overloads
355//===----------------------------------------------------------------------===//
356
357_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp)
358_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp)
359
360//===----------------------------------------------------------------------===//
361// exp2 builtins overloads
362//===----------------------------------------------------------------------===//
363
364_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp2)
365_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp2)
366
367//===----------------------------------------------------------------------===//
368// floor builtins overloads
369//===----------------------------------------------------------------------===//
370
371_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(floor)
372_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(floor)
373
374//===----------------------------------------------------------------------===//
375// frac builtins overloads
376//===----------------------------------------------------------------------===//
377
378_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(frac)
379_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
380
381//===----------------------------------------------------------------------===//
382// isinf builtins overloads
383//===----------------------------------------------------------------------===//
384
385_DXC_DEPRECATED_64BIT_FN(isinf)
386constexpr bool isinf(double V) { return isinf((float)V); }
387_DXC_DEPRECATED_64BIT_FN(isinf)
388constexpr bool2 isinf(double2 V) { return isinf((float2)V); }
389_DXC_DEPRECATED_64BIT_FN(isinf)
390constexpr bool3 isinf(double3 V) { return isinf((float3)V); }
391_DXC_DEPRECATED_64BIT_FN(isinf)
392constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
393_DXC_DEPRECATED_64BIT_FN(isinf)
394constexpr bool1x2 isinf(double1x2 V) { return isinf((float1x2)V); }
395_DXC_DEPRECATED_64BIT_FN(isinf)
396constexpr bool1x3 isinf(double1x3 V) { return isinf((float1x3)V); }
397_DXC_DEPRECATED_64BIT_FN(isinf)
398constexpr bool1x4 isinf(double1x4 V) { return isinf((float1x4)V); }
399_DXC_DEPRECATED_64BIT_FN(isinf)
400constexpr bool2x1 isinf(double2x1 V) { return isinf((float2x1)V); }
401_DXC_DEPRECATED_64BIT_FN(isinf)
402constexpr bool2x2 isinf(double2x2 V) { return isinf((float2x2)V); }
403_DXC_DEPRECATED_64BIT_FN(isinf)
404constexpr bool2x3 isinf(double2x3 V) { return isinf((float2x3)V); }
405_DXC_DEPRECATED_64BIT_FN(isinf)
406constexpr bool2x4 isinf(double2x4 V) { return isinf((float2x4)V); }
407_DXC_DEPRECATED_64BIT_FN(isinf)
408constexpr bool3x1 isinf(double3x1 V) { return isinf((float3x1)V); }
409_DXC_DEPRECATED_64BIT_FN(isinf)
410constexpr bool3x2 isinf(double3x2 V) { return isinf((float3x2)V); }
411_DXC_DEPRECATED_64BIT_FN(isinf)
412constexpr bool3x3 isinf(double3x3 V) { return isinf((float3x3)V); }
413_DXC_DEPRECATED_64BIT_FN(isinf)
414constexpr bool3x4 isinf(double3x4 V) { return isinf((float3x4)V); }
415_DXC_DEPRECATED_64BIT_FN(isinf)
416constexpr bool4x1 isinf(double4x1 V) { return isinf((float4x1)V); }
417_DXC_DEPRECATED_64BIT_FN(isinf)
418constexpr bool4x2 isinf(double4x2 V) { return isinf((float4x2)V); }
419_DXC_DEPRECATED_64BIT_FN(isinf)
420constexpr bool4x3 isinf(double4x3 V) { return isinf((float4x3)V); }
421_DXC_DEPRECATED_64BIT_FN(isinf)
422constexpr bool4x4 isinf(double4x4 V) { return isinf((float4x4)V); }
423
424//===----------------------------------------------------------------------===//
425// isnan builtins overloads
426//===----------------------------------------------------------------------===//
427
428_DXC_DEPRECATED_64BIT_FN(isnan)
429constexpr bool isnan(double V) { return isnan((float)V); }
430_DXC_DEPRECATED_64BIT_FN(isnan)
431constexpr bool2 isnan(double2 V) { return isnan((float2)V); }
432_DXC_DEPRECATED_64BIT_FN(isnan)
433constexpr bool3 isnan(double3 V) { return isnan((float3)V); }
434_DXC_DEPRECATED_64BIT_FN(isnan)
435constexpr bool4 isnan(double4 V) { return isnan((float4)V); }
436_DXC_DEPRECATED_64BIT_FN(isnan)
437constexpr bool1x2 isnan(double1x2 V) { return isnan((float1x2)V); }
438_DXC_DEPRECATED_64BIT_FN(isnan)
439constexpr bool1x3 isnan(double1x3 V) { return isnan((float1x3)V); }
440_DXC_DEPRECATED_64BIT_FN(isnan)
441constexpr bool1x4 isnan(double1x4 V) { return isnan((float1x4)V); }
442_DXC_DEPRECATED_64BIT_FN(isnan)
443constexpr bool2x1 isnan(double2x1 V) { return isnan((float2x1)V); }
444_DXC_DEPRECATED_64BIT_FN(isnan)
445constexpr bool2x2 isnan(double2x2 V) { return isnan((float2x2)V); }
446_DXC_DEPRECATED_64BIT_FN(isnan)
447constexpr bool2x3 isnan(double2x3 V) { return isnan((float2x3)V); }
448_DXC_DEPRECATED_64BIT_FN(isnan)
449constexpr bool2x4 isnan(double2x4 V) { return isnan((float2x4)V); }
450_DXC_DEPRECATED_64BIT_FN(isnan)
451constexpr bool3x1 isnan(double3x1 V) { return isnan((float3x1)V); }
452_DXC_DEPRECATED_64BIT_FN(isnan)
453constexpr bool3x2 isnan(double3x2 V) { return isnan((float3x2)V); }
454_DXC_DEPRECATED_64BIT_FN(isnan)
455constexpr bool3x3 isnan(double3x3 V) { return isnan((float3x3)V); }
456_DXC_DEPRECATED_64BIT_FN(isnan)
457constexpr bool3x4 isnan(double3x4 V) { return isnan((float3x4)V); }
458_DXC_DEPRECATED_64BIT_FN(isnan)
459constexpr bool4x1 isnan(double4x1 V) { return isnan((float4x1)V); }
460_DXC_DEPRECATED_64BIT_FN(isnan)
461constexpr bool4x2 isnan(double4x2 V) { return isnan((float4x2)V); }
462_DXC_DEPRECATED_64BIT_FN(isnan)
463constexpr bool4x3 isnan(double4x3 V) { return isnan((float4x3)V); }
464_DXC_DEPRECATED_64BIT_FN(isnan)
465constexpr bool4x4 isnan(double4x4 V) { return isnan((float4x4)V); }
466
467//===----------------------------------------------------------------------===//
468// lerp builtins overloads
469//===----------------------------------------------------------------------===//
470
471template <typename T, uint N>
472_DXC_DEPRECATED_VEC_SCALAR_FN(lerp)
473constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> lerp(
474 vector<T, N> x, vector<T, N> y, T s) {
475 return lerp(x, y, (vector<T, N>)s);
476}
477
478_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(lerp)
479_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(lerp)
480
481//===----------------------------------------------------------------------===//
482// log builtins overloads
483//===----------------------------------------------------------------------===//
484
485_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log)
486_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log)
487
488//===----------------------------------------------------------------------===//
489// log10 builtins overloads
490//===----------------------------------------------------------------------===//
491
492_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log10)
493_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log10)
494
495//===----------------------------------------------------------------------===//
496// log2 builtins overloads
497//===----------------------------------------------------------------------===//
498
499_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log2)
500_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)
501
502//===----------------------------------------------------------------------===//
503// max builtins overloads
504//===----------------------------------------------------------------------===//
505
506template <typename T, uint N>
507_DXC_DEPRECATED_VEC_SCALAR_FN(max)
508constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
509 vector<T, N> p0, T p1) {
510 return max(p0, (vector<T, N>)p1);
511}
512
513template <typename T, uint N>
514_DXC_DEPRECATED_VEC_SCALAR_FN(max)
515constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> max(
516 T p0, vector<T, N> p1) {
517 return max((vector<T, N>)p0, p1);
518}
519
520//===----------------------------------------------------------------------===//
521// min builtins overloads
522//===----------------------------------------------------------------------===//
523
524template <typename T, uint N>
525_DXC_DEPRECATED_VEC_SCALAR_FN(min)
526constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(
527 vector<T, N> p0, T p1) {
528 return min(p0, (vector<T, N>)p1);
529}
530
531template <typename T, uint N>
532_DXC_DEPRECATED_VEC_SCALAR_FN(min)
533constexpr __detail::enable_if_t<(N > 1 && N <= 4), vector<T, N>> min(
534 T p0, vector<T, N> p1) {
535 return min((vector<T, N>)p0, p1);
536}
537
538//===----------------------------------------------------------------------===//
539// normalize builtins overloads
540//===----------------------------------------------------------------------===//
541
542_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(normalize)
543_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(normalize)
544
545//===----------------------------------------------------------------------===//
546// pow builtins overloads
547//===----------------------------------------------------------------------===//
548
549_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(pow)
550_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(pow)
551_DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(pow)
552_DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(pow)
553
554//===----------------------------------------------------------------------===//
555// rsqrt builtins overloads
556//===----------------------------------------------------------------------===//
557
558_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(rsqrt)
559_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(rsqrt)
560
561//===----------------------------------------------------------------------===//
562// round builtins overloads
563//===----------------------------------------------------------------------===//
564
565_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(round)
566_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(round)
567
568//===----------------------------------------------------------------------===//
569// sin builtins overloads
570//===----------------------------------------------------------------------===//
571
572_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sin)
573_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sin)
574
575//===----------------------------------------------------------------------===//
576// sinh builtins overloads
577//===----------------------------------------------------------------------===//
578
579_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sinh)
580_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sinh)
581
582//===----------------------------------------------------------------------===//
583// sqrt builtins overloads
584//===----------------------------------------------------------------------===//
585
586_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sqrt)
587_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sqrt)
588
589//===----------------------------------------------------------------------===//
590// step builtins overloads
591//===----------------------------------------------------------------------===//
592
593_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(step)
594_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(step)
595
596//===----------------------------------------------------------------------===//
597// tan builtins overloads
598//===----------------------------------------------------------------------===//
599
600_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tan)
601_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tan)
602
603//===----------------------------------------------------------------------===//
604// tanh builtins overloads
605//===----------------------------------------------------------------------===//
606
607_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tanh)
608_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tanh)
609
610//===----------------------------------------------------------------------===//
611// trunc builtins overloads
612//===----------------------------------------------------------------------===//
613
614_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(trunc)
615_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(trunc)
616
617//===----------------------------------------------------------------------===//
618// radians builtins overloads
619//===----------------------------------------------------------------------===//
620
621_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(radians)
622_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(radians)
623
624} // namespace hlsl
625#endif // _HLSL_COMPAT_OVERLOADS_H_
V
#define V(N, I)
Definition ASTContext.h:3788
isnan
__DEVICE__ bool isnan(float __x)
Test for a NaN.
Definition __clang_cuda_cmath.h:108
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:41
_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:167
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:31
_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS
#define _DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:59
_DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS
#define _DXC_COMPAT_BINARY_INTEGER_MATRIX_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:241
_DXC_COMPAT_UNARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:77
_DXC_COMPAT_BINARY_INTEGER_OVERLOADS
#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:111
_DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS
#define _DXC_COMPAT_BINARY_DOUBLE_MATRIX_OVERLOADS(fn)
Definition hlsl_compat_overloads.h:233
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::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:386
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:473
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:508
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:526
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:313
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:429
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