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