Warning: This file is not a C or C++ file. It does not have highlighting.
1 | //===----- hlsl_intrinsics.h - HLSL definitions for intrinsics ----------===// |
---|---|
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #ifndef _HLSL_HLSL_INTRINSICS_H_ |
10 | #define _HLSL_HLSL_INTRINSICS_H_ |
11 | |
12 | namespace 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 singed integer, |
16 | // unsigned integer and floating point. Keeping this ordering consistent will |
17 | // help keep this file manageable as it grows. |
18 | |
19 | #define _HLSL_BUILTIN_ALIAS(builtin) \ |
20 | __attribute__((clang_builtin_alias(builtin))) |
21 | #define _HLSL_AVAILABILITY(environment, version) \ |
22 | __attribute__((availability(environment, introduced = version))) |
23 | |
24 | #ifdef __HLSL_ENABLE_16_BIT |
25 | #define _HLSL_16BIT_AVAILABILITY(environment, version) \ |
26 | __attribute__((availability(environment, introduced = version))) |
27 | #else |
28 | #define _HLSL_16BIT_AVAILABILITY(environment, version) |
29 | #endif |
30 | |
31 | //===----------------------------------------------------------------------===// |
32 | // abs builtins |
33 | //===----------------------------------------------------------------------===// |
34 | |
35 | /// \fn T abs(T Val) |
36 | /// \brief Returns the absolute value of the input value, \a Val. |
37 | /// \param Val The input value. |
38 | |
39 | #ifdef __HLSL_ENABLE_16_BIT |
40 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
41 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
42 | int16_t abs(int16_t); |
43 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
44 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
45 | int16_t2 abs(int16_t2); |
46 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
47 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
48 | int16_t3 abs(int16_t3); |
49 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
50 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
51 | int16_t4 abs(int16_t4); |
52 | #endif |
53 | |
54 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
55 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
56 | half abs(half); |
57 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
58 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
59 | half2 abs(half2); |
60 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
61 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
62 | half3 abs(half3); |
63 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
64 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
65 | half4 abs(half4); |
66 | |
67 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
68 | int abs(int); |
69 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
70 | int2 abs(int2); |
71 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
72 | int3 abs(int3); |
73 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
74 | int4 abs(int4); |
75 | |
76 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
77 | float abs(float); |
78 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
79 | float2 abs(float2); |
80 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
81 | float3 abs(float3); |
82 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
83 | float4 abs(float4); |
84 | |
85 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
86 | int64_t abs(int64_t); |
87 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
88 | int64_t2 abs(int64_t2); |
89 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
90 | int64_t3 abs(int64_t3); |
91 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
92 | int64_t4 abs(int64_t4); |
93 | |
94 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
95 | double abs(double); |
96 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
97 | double2 abs(double2); |
98 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
99 | double3 abs(double3); |
100 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_abs) |
101 | double4 abs(double4); |
102 | |
103 | //===----------------------------------------------------------------------===// |
104 | // all builtins |
105 | //===----------------------------------------------------------------------===// |
106 | |
107 | /// \fn bool all(T x) |
108 | /// \brief Returns True if all components of the \a x parameter are non-zero; |
109 | /// otherwise, false. \param x The input value. |
110 | |
111 | #ifdef __HLSL_ENABLE_16_BIT |
112 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
113 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
114 | bool all(int16_t); |
115 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
116 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
117 | bool all(int16_t2); |
118 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
119 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
120 | bool all(int16_t3); |
121 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
122 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
123 | bool all(int16_t4); |
124 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
125 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
126 | bool all(uint16_t); |
127 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
128 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
129 | bool all(uint16_t2); |
130 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
131 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
132 | bool all(uint16_t3); |
133 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
134 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
135 | bool all(uint16_t4); |
136 | #endif |
137 | |
138 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
139 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
140 | bool all(half); |
141 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
142 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
143 | bool all(half2); |
144 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
145 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
146 | bool all(half3); |
147 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
148 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
149 | bool all(half4); |
150 | |
151 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
152 | bool all(bool); |
153 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
154 | bool all(bool2); |
155 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
156 | bool all(bool3); |
157 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
158 | bool all(bool4); |
159 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
160 | |
161 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
162 | bool all(int); |
163 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
164 | bool all(int2); |
165 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
166 | bool all(int3); |
167 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
168 | bool all(int4); |
169 | |
170 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
171 | bool all(uint); |
172 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
173 | bool all(uint2); |
174 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
175 | bool all(uint3); |
176 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
177 | bool all(uint4); |
178 | |
179 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
180 | bool all(float); |
181 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
182 | bool all(float2); |
183 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
184 | bool all(float3); |
185 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
186 | bool all(float4); |
187 | |
188 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
189 | bool all(int64_t); |
190 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
191 | bool all(int64_t2); |
192 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
193 | bool all(int64_t3); |
194 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
195 | bool all(int64_t4); |
196 | |
197 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
198 | bool all(uint64_t); |
199 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
200 | bool all(uint64_t2); |
201 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
202 | bool all(uint64_t3); |
203 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
204 | bool all(uint64_t4); |
205 | |
206 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
207 | bool all(double); |
208 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
209 | bool all(double2); |
210 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
211 | bool all(double3); |
212 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_all) |
213 | bool all(double4); |
214 | |
215 | //===----------------------------------------------------------------------===// |
216 | // any builtins |
217 | //===----------------------------------------------------------------------===// |
218 | |
219 | /// \fn bool any(T x) |
220 | /// \brief Returns True if any components of the \a x parameter are non-zero; |
221 | /// otherwise, false. \param x The input value. |
222 | |
223 | #ifdef __HLSL_ENABLE_16_BIT |
224 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
225 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
226 | bool any(int16_t); |
227 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
228 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
229 | bool any(int16_t2); |
230 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
231 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
232 | bool any(int16_t3); |
233 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
234 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
235 | bool any(int16_t4); |
236 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
237 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
238 | bool any(uint16_t); |
239 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
240 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
241 | bool any(uint16_t2); |
242 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
243 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
244 | bool any(uint16_t3); |
245 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
246 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
247 | bool any(uint16_t4); |
248 | #endif |
249 | |
250 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
251 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
252 | bool any(half); |
253 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
254 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
255 | bool any(half2); |
256 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
257 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
258 | bool any(half3); |
259 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
260 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
261 | bool any(half4); |
262 | |
263 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
264 | bool any(bool); |
265 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
266 | bool any(bool2); |
267 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
268 | bool any(bool3); |
269 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
270 | bool any(bool4); |
271 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
272 | |
273 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
274 | bool any(int); |
275 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
276 | bool any(int2); |
277 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
278 | bool any(int3); |
279 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
280 | bool any(int4); |
281 | |
282 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
283 | bool any(uint); |
284 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
285 | bool any(uint2); |
286 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
287 | bool any(uint3); |
288 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
289 | bool any(uint4); |
290 | |
291 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
292 | bool any(float); |
293 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
294 | bool any(float2); |
295 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
296 | bool any(float3); |
297 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
298 | bool any(float4); |
299 | |
300 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
301 | bool any(int64_t); |
302 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
303 | bool any(int64_t2); |
304 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
305 | bool any(int64_t3); |
306 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
307 | bool any(int64_t4); |
308 | |
309 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
310 | bool any(uint64_t); |
311 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
312 | bool any(uint64_t2); |
313 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
314 | bool any(uint64_t3); |
315 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
316 | bool any(uint64_t4); |
317 | |
318 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
319 | bool any(double); |
320 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
321 | bool any(double2); |
322 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
323 | bool any(double3); |
324 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_any) |
325 | bool any(double4); |
326 | |
327 | //===----------------------------------------------------------------------===// |
328 | // ceil builtins |
329 | //===----------------------------------------------------------------------===// |
330 | |
331 | /// \fn T ceil(T Val) |
332 | /// \brief Returns the smallest integer value that is greater than or equal to |
333 | /// the input value, \a Val. |
334 | /// \param Val The input value. |
335 | |
336 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
337 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
338 | half ceil(half); |
339 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
340 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
341 | half2 ceil(half2); |
342 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
343 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
344 | half3 ceil(half3); |
345 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
346 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
347 | half4 ceil(half4); |
348 | |
349 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
350 | float ceil(float); |
351 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
352 | float2 ceil(float2); |
353 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
354 | float3 ceil(float3); |
355 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_ceil) |
356 | float4 ceil(float4); |
357 | |
358 | //===----------------------------------------------------------------------===// |
359 | // clamp builtins |
360 | //===----------------------------------------------------------------------===// |
361 | |
362 | /// \fn T clamp(T X, T Min, T Max) |
363 | /// \brief Clamps the specified value \a X to the specified |
364 | /// minimum ( \a Min) and maximum ( \a Max) range. |
365 | /// \param X A value to clamp. |
366 | /// \param Min The specified minimum range. |
367 | /// \param Max The specified maximum range. |
368 | /// |
369 | /// Returns The clamped value for the \a X parameter. |
370 | /// For values of -INF or INF, clamp will behave as expected. |
371 | /// However for values of NaN, the results are undefined. |
372 | |
373 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
374 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
375 | half clamp(half, half, half); |
376 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
377 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
378 | half2 clamp(half2, half2, half2); |
379 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
380 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
381 | half3 clamp(half3, half3, half3); |
382 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
383 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
384 | half4 clamp(half4, half4, half4); |
385 | |
386 | #ifdef __HLSL_ENABLE_16_BIT |
387 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
388 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
389 | int16_t clamp(int16_t, int16_t, int16_t); |
390 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
391 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
392 | int16_t2 clamp(int16_t2, int16_t2, int16_t2); |
393 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
394 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
395 | int16_t3 clamp(int16_t3, int16_t3, int16_t3); |
396 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
397 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
398 | int16_t4 clamp(int16_t4, int16_t4, int16_t4); |
399 | |
400 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
401 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
402 | uint16_t clamp(uint16_t, uint16_t, uint16_t); |
403 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
404 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
405 | uint16_t2 clamp(uint16_t2, uint16_t2, uint16_t2); |
406 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
407 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
408 | uint16_t3 clamp(uint16_t3, uint16_t3, uint16_t3); |
409 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
410 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
411 | uint16_t4 clamp(uint16_t4, uint16_t4, uint16_t4); |
412 | #endif |
413 | |
414 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
415 | int clamp(int, int, int); |
416 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
417 | int2 clamp(int2, int2, int2); |
418 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
419 | int3 clamp(int3, int3, int3); |
420 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
421 | int4 clamp(int4, int4, int4); |
422 | |
423 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
424 | uint clamp(uint, uint, uint); |
425 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
426 | uint2 clamp(uint2, uint2, uint2); |
427 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
428 | uint3 clamp(uint3, uint3, uint3); |
429 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
430 | uint4 clamp(uint4, uint4, uint4); |
431 | |
432 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
433 | int64_t clamp(int64_t, int64_t, int64_t); |
434 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
435 | int64_t2 clamp(int64_t2, int64_t2, int64_t2); |
436 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
437 | int64_t3 clamp(int64_t3, int64_t3, int64_t3); |
438 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
439 | int64_t4 clamp(int64_t4, int64_t4, int64_t4); |
440 | |
441 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
442 | uint64_t clamp(uint64_t, uint64_t, uint64_t); |
443 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
444 | uint64_t2 clamp(uint64_t2, uint64_t2, uint64_t2); |
445 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
446 | uint64_t3 clamp(uint64_t3, uint64_t3, uint64_t3); |
447 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
448 | uint64_t4 clamp(uint64_t4, uint64_t4, uint64_t4); |
449 | |
450 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
451 | float clamp(float, float, float); |
452 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
453 | float2 clamp(float2, float2, float2); |
454 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
455 | float3 clamp(float3, float3, float3); |
456 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
457 | float4 clamp(float4, float4, float4); |
458 | |
459 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
460 | double clamp(double, double, double); |
461 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
462 | double2 clamp(double2, double2, double2); |
463 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
464 | double3 clamp(double3, double3, double3); |
465 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_clamp) |
466 | double4 clamp(double4, double4, double4); |
467 | |
468 | //===----------------------------------------------------------------------===// |
469 | // cos builtins |
470 | //===----------------------------------------------------------------------===// |
471 | |
472 | /// \fn T cos(T Val) |
473 | /// \brief Returns the cosine of the input value, \a Val. |
474 | /// \param Val The input value. |
475 | |
476 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
477 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
478 | half cos(half); |
479 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
480 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
481 | half2 cos(half2); |
482 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
483 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
484 | half3 cos(half3); |
485 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
486 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
487 | half4 cos(half4); |
488 | |
489 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
490 | float cos(float); |
491 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
492 | float2 cos(float2); |
493 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
494 | float3 cos(float3); |
495 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_cos) |
496 | float4 cos(float4); |
497 | |
498 | //===----------------------------------------------------------------------===// |
499 | // dot product builtins |
500 | //===----------------------------------------------------------------------===// |
501 | |
502 | /// \fn K dot(T X, T Y) |
503 | /// \brief Return the dot product (a scalar value) of \a X and \a Y. |
504 | /// \param X The X input value. |
505 | /// \param Y The Y input value. |
506 | |
507 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
508 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
509 | half dot(half, half); |
510 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
511 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
512 | half dot(half2, half2); |
513 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
514 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
515 | half dot(half3, half3); |
516 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
517 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
518 | half dot(half4, half4); |
519 | |
520 | #ifdef __HLSL_ENABLE_16_BIT |
521 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
522 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
523 | int16_t dot(int16_t, int16_t); |
524 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
525 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
526 | int16_t dot(int16_t2, int16_t2); |
527 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
528 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
529 | int16_t dot(int16_t3, int16_t3); |
530 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
531 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
532 | int16_t dot(int16_t4, int16_t4); |
533 | |
534 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
535 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
536 | uint16_t dot(uint16_t, uint16_t); |
537 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
538 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
539 | uint16_t dot(uint16_t2, uint16_t2); |
540 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
541 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
542 | uint16_t dot(uint16_t3, uint16_t3); |
543 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
544 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
545 | uint16_t dot(uint16_t4, uint16_t4); |
546 | #endif |
547 | |
548 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
549 | float dot(float, float); |
550 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
551 | float dot(float2, float2); |
552 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
553 | float dot(float3, float3); |
554 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
555 | float dot(float4, float4); |
556 | |
557 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
558 | double dot(double, double); |
559 | |
560 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
561 | int dot(int, int); |
562 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
563 | int dot(int2, int2); |
564 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
565 | int dot(int3, int3); |
566 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
567 | int dot(int4, int4); |
568 | |
569 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
570 | uint dot(uint, uint); |
571 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
572 | uint dot(uint2, uint2); |
573 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
574 | uint dot(uint3, uint3); |
575 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
576 | uint dot(uint4, uint4); |
577 | |
578 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
579 | int64_t dot(int64_t, int64_t); |
580 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
581 | int64_t dot(int64_t2, int64_t2); |
582 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
583 | int64_t dot(int64_t3, int64_t3); |
584 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
585 | int64_t dot(int64_t4, int64_t4); |
586 | |
587 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
588 | uint64_t dot(uint64_t, uint64_t); |
589 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
590 | uint64_t dot(uint64_t2, uint64_t2); |
591 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
592 | uint64_t dot(uint64_t3, uint64_t3); |
593 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_dot) |
594 | uint64_t dot(uint64_t4, uint64_t4); |
595 | |
596 | //===----------------------------------------------------------------------===// |
597 | // exp builtins |
598 | //===----------------------------------------------------------------------===// |
599 | |
600 | /// \fn T exp(T x) |
601 | /// \brief Returns the base-e exponential, or \a e**x, of the specified value. |
602 | /// \param x The specified input value. |
603 | /// |
604 | /// The return value is the base-e exponential of the \a x parameter. |
605 | |
606 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
607 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
608 | half exp(half); |
609 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
610 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
611 | half2 exp(half2); |
612 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
613 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
614 | half3 exp(half3); |
615 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
616 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
617 | half4 exp(half4); |
618 | |
619 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
620 | float exp(float); |
621 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
622 | float2 exp(float2); |
623 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
624 | float3 exp(float3); |
625 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp) |
626 | float4 exp(float4); |
627 | |
628 | //===----------------------------------------------------------------------===// |
629 | // exp2 builtins |
630 | //===----------------------------------------------------------------------===// |
631 | |
632 | /// \fn T exp2(T x) |
633 | /// \brief Returns the base 2 exponential, or \a 2**x, of the specified value. |
634 | /// \param x The specified input value. |
635 | /// |
636 | /// The base 2 exponential of the \a x parameter. |
637 | |
638 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
639 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
640 | half exp2(half); |
641 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
642 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
643 | half2 exp2(half2); |
644 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
645 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
646 | half3 exp2(half3); |
647 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
648 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
649 | half4 exp2(half4); |
650 | |
651 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
652 | float exp2(float); |
653 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
654 | float2 exp2(float2); |
655 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
656 | float3 exp2(float3); |
657 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_exp2) |
658 | float4 exp2(float4); |
659 | |
660 | //===----------------------------------------------------------------------===// |
661 | // floor builtins |
662 | //===----------------------------------------------------------------------===// |
663 | |
664 | /// \fn T floor(T Val) |
665 | /// \brief Returns the largest integer that is less than or equal to the input |
666 | /// value, \a Val. |
667 | /// \param Val The input value. |
668 | |
669 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
670 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
671 | half floor(half); |
672 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
673 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
674 | half2 floor(half2); |
675 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
676 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
677 | half3 floor(half3); |
678 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
679 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
680 | half4 floor(half4); |
681 | |
682 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
683 | float floor(float); |
684 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
685 | float2 floor(float2); |
686 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
687 | float3 floor(float3); |
688 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_floor) |
689 | float4 floor(float4); |
690 | |
691 | //===----------------------------------------------------------------------===// |
692 | // frac builtins |
693 | //===----------------------------------------------------------------------===// |
694 | |
695 | /// \fn T frac(T x) |
696 | /// \brief Returns the fractional (or decimal) part of x. \a x parameter. |
697 | /// \param x The specified input value. |
698 | /// |
699 | /// If \a the return value is greater than or equal to 0 and less than 1. |
700 | |
701 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
702 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
703 | half frac(half); |
704 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
705 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
706 | half2 frac(half2); |
707 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
708 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
709 | half3 frac(half3); |
710 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
711 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
712 | half4 frac(half4); |
713 | |
714 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
715 | float frac(float); |
716 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
717 | float2 frac(float2); |
718 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
719 | float3 frac(float3); |
720 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_frac) |
721 | float4 frac(float4); |
722 | |
723 | //===----------------------------------------------------------------------===// |
724 | // isinf builtins |
725 | //===----------------------------------------------------------------------===// |
726 | |
727 | /// \fn T isinf(T x) |
728 | /// \brief Determines if the specified value \a x is infinite. |
729 | /// \param x The specified input value. |
730 | /// |
731 | /// Returns a value of the same size as the input, with a value set |
732 | /// to True if the x parameter is +INF or -INF. Otherwise, False. |
733 | |
734 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
735 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
736 | bool isinf(half); |
737 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
738 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
739 | bool2 isinf(half2); |
740 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
741 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
742 | bool3 isinf(half3); |
743 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
744 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
745 | bool4 isinf(half4); |
746 | |
747 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
748 | bool isinf(float); |
749 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
750 | bool2 isinf(float2); |
751 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
752 | bool3 isinf(float3); |
753 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_isinf) |
754 | bool4 isinf(float4); |
755 | |
756 | //===----------------------------------------------------------------------===// |
757 | // lerp builtins |
758 | //===----------------------------------------------------------------------===// |
759 | |
760 | /// \fn T lerp(T x, T y, T s) |
761 | /// \brief Returns the linear interpolation of x to y by s. |
762 | /// \param x [in] The first-floating point value. |
763 | /// \param y [in] The second-floating point value. |
764 | /// \param s [in] A value that linearly interpolates between the x parameter and |
765 | /// the y parameter. |
766 | /// |
767 | /// Linear interpolation is based on the following formula: x*(1-s) + y*s which |
768 | /// can equivalently be written as x + s(y-x). |
769 | |
770 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
771 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
772 | half lerp(half, half, half); |
773 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
774 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
775 | half2 lerp(half2, half2, half2); |
776 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
777 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
778 | half3 lerp(half3, half3, half3); |
779 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
780 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
781 | half4 lerp(half4, half4, half4); |
782 | |
783 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
784 | float lerp(float, float, float); |
785 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
786 | float2 lerp(float2, float2, float2); |
787 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
788 | float3 lerp(float3, float3, float3); |
789 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_lerp) |
790 | float4 lerp(float4, float4, float4); |
791 | |
792 | //===----------------------------------------------------------------------===// |
793 | // log builtins |
794 | //===----------------------------------------------------------------------===// |
795 | |
796 | /// \fn T log(T Val) |
797 | /// \brief The base-e logarithm of the input value, \a Val parameter. |
798 | /// \param Val The input value. |
799 | /// |
800 | /// If \a Val is negative, this result is undefined. If \a Val is 0, this |
801 | /// function returns negative infinity. |
802 | |
803 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
804 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
805 | half log(half); |
806 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
807 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
808 | half2 log(half2); |
809 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
810 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
811 | half3 log(half3); |
812 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
813 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
814 | half4 log(half4); |
815 | |
816 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
817 | float log(float); |
818 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
819 | float2 log(float2); |
820 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
821 | float3 log(float3); |
822 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log) |
823 | float4 log(float4); |
824 | |
825 | //===----------------------------------------------------------------------===// |
826 | // log10 builtins |
827 | //===----------------------------------------------------------------------===// |
828 | |
829 | /// \fn T log10(T Val) |
830 | /// \brief The base-10 logarithm of the input value, \a Val parameter. |
831 | /// \param Val The input value. |
832 | /// |
833 | /// If \a Val is negative, this result is undefined. If \a Val is 0, this |
834 | /// function returns negative infinity. |
835 | |
836 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
837 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
838 | half log10(half); |
839 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
840 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
841 | half2 log10(half2); |
842 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
843 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
844 | half3 log10(half3); |
845 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
846 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
847 | half4 log10(half4); |
848 | |
849 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
850 | float log10(float); |
851 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
852 | float2 log10(float2); |
853 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
854 | float3 log10(float3); |
855 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log10) |
856 | float4 log10(float4); |
857 | |
858 | //===----------------------------------------------------------------------===// |
859 | // log2 builtins |
860 | //===----------------------------------------------------------------------===// |
861 | |
862 | /// \fn T log2(T Val) |
863 | /// \brief The base-2 logarithm of the input value, \a Val parameter. |
864 | /// \param Val The input value. |
865 | /// |
866 | /// If \a Val is negative, this result is undefined. If \a Val is 0, this |
867 | /// function returns negative infinity. |
868 | |
869 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
870 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
871 | half log2(half); |
872 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
873 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
874 | half2 log2(half2); |
875 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
876 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
877 | half3 log2(half3); |
878 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
879 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
880 | half4 log2(half4); |
881 | |
882 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
883 | float log2(float); |
884 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
885 | float2 log2(float2); |
886 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
887 | float3 log2(float3); |
888 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_log2) |
889 | float4 log2(float4); |
890 | |
891 | //===----------------------------------------------------------------------===// |
892 | // mad builtins |
893 | //===----------------------------------------------------------------------===// |
894 | |
895 | /// \fn T mad(T M, T A, T B) |
896 | /// \brief The result of \a M * \a A + \a B. |
897 | /// \param M The multiplication value. |
898 | /// \param A The first addition value. |
899 | /// \param B The second addition value. |
900 | |
901 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
902 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
903 | half mad(half, half, half); |
904 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
905 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
906 | half2 mad(half2, half2, half2); |
907 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
908 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
909 | half3 mad(half3, half3, half3); |
910 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
911 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
912 | half4 mad(half4, half4, half4); |
913 | |
914 | #ifdef __HLSL_ENABLE_16_BIT |
915 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
916 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
917 | int16_t mad(int16_t, int16_t, int16_t); |
918 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
919 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
920 | int16_t2 mad(int16_t2, int16_t2, int16_t2); |
921 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
922 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
923 | int16_t3 mad(int16_t3, int16_t3, int16_t3); |
924 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
925 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
926 | int16_t4 mad(int16_t4, int16_t4, int16_t4); |
927 | |
928 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
929 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
930 | uint16_t mad(uint16_t, uint16_t, uint16_t); |
931 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
932 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
933 | uint16_t2 mad(uint16_t2, uint16_t2, uint16_t2); |
934 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
935 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
936 | uint16_t3 mad(uint16_t3, uint16_t3, uint16_t3); |
937 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
938 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
939 | uint16_t4 mad(uint16_t4, uint16_t4, uint16_t4); |
940 | #endif |
941 | |
942 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
943 | int mad(int, int, int); |
944 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
945 | int2 mad(int2, int2, int2); |
946 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
947 | int3 mad(int3, int3, int3); |
948 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
949 | int4 mad(int4, int4, int4); |
950 | |
951 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
952 | uint mad(uint, uint, uint); |
953 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
954 | uint2 mad(uint2, uint2, uint2); |
955 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
956 | uint3 mad(uint3, uint3, uint3); |
957 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
958 | uint4 mad(uint4, uint4, uint4); |
959 | |
960 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
961 | int64_t mad(int64_t, int64_t, int64_t); |
962 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
963 | int64_t2 mad(int64_t2, int64_t2, int64_t2); |
964 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
965 | int64_t3 mad(int64_t3, int64_t3, int64_t3); |
966 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
967 | int64_t4 mad(int64_t4, int64_t4, int64_t4); |
968 | |
969 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
970 | uint64_t mad(uint64_t, uint64_t, uint64_t); |
971 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
972 | uint64_t2 mad(uint64_t2, uint64_t2, uint64_t2); |
973 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
974 | uint64_t3 mad(uint64_t3, uint64_t3, uint64_t3); |
975 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
976 | uint64_t4 mad(uint64_t4, uint64_t4, uint64_t4); |
977 | |
978 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
979 | float mad(float, float, float); |
980 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
981 | float2 mad(float2, float2, float2); |
982 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
983 | float3 mad(float3, float3, float3); |
984 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
985 | float4 mad(float4, float4, float4); |
986 | |
987 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
988 | double mad(double, double, double); |
989 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
990 | double2 mad(double2, double2, double2); |
991 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
992 | double3 mad(double3, double3, double3); |
993 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_mad) |
994 | double4 mad(double4, double4, double4); |
995 | |
996 | //===----------------------------------------------------------------------===// |
997 | // max builtins |
998 | //===----------------------------------------------------------------------===// |
999 | |
1000 | /// \fn T max(T X, T Y) |
1001 | /// \brief Return the greater of \a X and \a Y. |
1002 | /// \param X The X input value. |
1003 | /// \param Y The Y input value. |
1004 | |
1005 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1006 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1007 | half max(half, half); |
1008 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1009 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1010 | half2 max(half2, half2); |
1011 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1012 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1013 | half3 max(half3, half3); |
1014 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1015 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1016 | half4 max(half4, half4); |
1017 | |
1018 | #ifdef __HLSL_ENABLE_16_BIT |
1019 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1020 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1021 | int16_t max(int16_t, int16_t); |
1022 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1023 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1024 | int16_t2 max(int16_t2, int16_t2); |
1025 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1026 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1027 | int16_t3 max(int16_t3, int16_t3); |
1028 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1029 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1030 | int16_t4 max(int16_t4, int16_t4); |
1031 | |
1032 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1033 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1034 | uint16_t max(uint16_t, uint16_t); |
1035 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1036 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1037 | uint16_t2 max(uint16_t2, uint16_t2); |
1038 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1039 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1040 | uint16_t3 max(uint16_t3, uint16_t3); |
1041 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1042 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1043 | uint16_t4 max(uint16_t4, uint16_t4); |
1044 | #endif |
1045 | |
1046 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1047 | int max(int, int); |
1048 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1049 | int2 max(int2, int2); |
1050 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1051 | int3 max(int3, int3); |
1052 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1053 | int4 max(int4, int4); |
1054 | |
1055 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1056 | uint max(uint, uint); |
1057 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1058 | uint2 max(uint2, uint2); |
1059 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1060 | uint3 max(uint3, uint3); |
1061 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1062 | uint4 max(uint4, uint4); |
1063 | |
1064 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1065 | int64_t max(int64_t, int64_t); |
1066 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1067 | int64_t2 max(int64_t2, int64_t2); |
1068 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1069 | int64_t3 max(int64_t3, int64_t3); |
1070 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1071 | int64_t4 max(int64_t4, int64_t4); |
1072 | |
1073 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1074 | uint64_t max(uint64_t, uint64_t); |
1075 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1076 | uint64_t2 max(uint64_t2, uint64_t2); |
1077 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1078 | uint64_t3 max(uint64_t3, uint64_t3); |
1079 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1080 | uint64_t4 max(uint64_t4, uint64_t4); |
1081 | |
1082 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1083 | float max(float, float); |
1084 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1085 | float2 max(float2, float2); |
1086 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1087 | float3 max(float3, float3); |
1088 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1089 | float4 max(float4, float4); |
1090 | |
1091 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1092 | double max(double, double); |
1093 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1094 | double2 max(double2, double2); |
1095 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1096 | double3 max(double3, double3); |
1097 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max) |
1098 | double4 max(double4, double4); |
1099 | |
1100 | //===----------------------------------------------------------------------===// |
1101 | // min builtins |
1102 | //===----------------------------------------------------------------------===// |
1103 | |
1104 | /// \fn T min(T X, T Y) |
1105 | /// \brief Return the lesser of \a X and \a Y. |
1106 | /// \param X The X input value. |
1107 | /// \param Y The Y input value. |
1108 | |
1109 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1110 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1111 | half min(half, half); |
1112 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1113 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1114 | half2 min(half2, half2); |
1115 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1116 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1117 | half3 min(half3, half3); |
1118 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1119 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1120 | half4 min(half4, half4); |
1121 | |
1122 | #ifdef __HLSL_ENABLE_16_BIT |
1123 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1124 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1125 | int16_t min(int16_t, int16_t); |
1126 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1127 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1128 | int16_t2 min(int16_t2, int16_t2); |
1129 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1130 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1131 | int16_t3 min(int16_t3, int16_t3); |
1132 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1133 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1134 | int16_t4 min(int16_t4, int16_t4); |
1135 | |
1136 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1137 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1138 | uint16_t min(uint16_t, uint16_t); |
1139 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1140 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1141 | uint16_t2 min(uint16_t2, uint16_t2); |
1142 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1143 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1144 | uint16_t3 min(uint16_t3, uint16_t3); |
1145 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1146 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1147 | uint16_t4 min(uint16_t4, uint16_t4); |
1148 | #endif |
1149 | |
1150 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1151 | int min(int, int); |
1152 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1153 | int2 min(int2, int2); |
1154 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1155 | int3 min(int3, int3); |
1156 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1157 | int4 min(int4, int4); |
1158 | |
1159 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1160 | uint min(uint, uint); |
1161 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1162 | uint2 min(uint2, uint2); |
1163 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1164 | uint3 min(uint3, uint3); |
1165 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1166 | uint4 min(uint4, uint4); |
1167 | |
1168 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1169 | float min(float, float); |
1170 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1171 | float2 min(float2, float2); |
1172 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1173 | float3 min(float3, float3); |
1174 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1175 | float4 min(float4, float4); |
1176 | |
1177 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1178 | int64_t min(int64_t, int64_t); |
1179 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1180 | int64_t2 min(int64_t2, int64_t2); |
1181 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1182 | int64_t3 min(int64_t3, int64_t3); |
1183 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1184 | int64_t4 min(int64_t4, int64_t4); |
1185 | |
1186 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1187 | uint64_t min(uint64_t, uint64_t); |
1188 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1189 | uint64_t2 min(uint64_t2, uint64_t2); |
1190 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1191 | uint64_t3 min(uint64_t3, uint64_t3); |
1192 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1193 | uint64_t4 min(uint64_t4, uint64_t4); |
1194 | |
1195 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1196 | double min(double, double); |
1197 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1198 | double2 min(double2, double2); |
1199 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1200 | double3 min(double3, double3); |
1201 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min) |
1202 | double4 min(double4, double4); |
1203 | |
1204 | //===----------------------------------------------------------------------===// |
1205 | // pow builtins |
1206 | //===----------------------------------------------------------------------===// |
1207 | |
1208 | /// \fn T pow(T Val, T Pow) |
1209 | /// \brief Return the value \a Val, raised to the power \a Pow. |
1210 | /// \param Val The input value. |
1211 | /// \param Pow The specified power. |
1212 | |
1213 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1214 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1215 | half pow(half, half); |
1216 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1217 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1218 | half2 pow(half2, half2); |
1219 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1220 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1221 | half3 pow(half3, half3); |
1222 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1223 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1224 | half4 pow(half4, half4); |
1225 | |
1226 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1227 | float pow(float, float); |
1228 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1229 | float2 pow(float2, float2); |
1230 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1231 | float3 pow(float3, float3); |
1232 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_pow) |
1233 | float4 pow(float4, float4); |
1234 | |
1235 | //===----------------------------------------------------------------------===// |
1236 | // reversebits builtins |
1237 | //===----------------------------------------------------------------------===// |
1238 | |
1239 | /// \fn T reversebits(T Val) |
1240 | /// \brief Return the value \a Val with the bit order reversed. |
1241 | /// \param Val The input value. |
1242 | |
1243 | #ifdef __HLSL_ENABLE_16_BIT |
1244 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1245 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1246 | uint16_t reversebits(uint16_t); |
1247 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1248 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1249 | uint16_t2 reversebits(uint16_t2); |
1250 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1251 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1252 | uint16_t3 reversebits(uint16_t3); |
1253 | _HLSL_AVAILABILITY(shadermodel, 6.2) |
1254 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1255 | uint16_t4 reversebits(uint16_t4); |
1256 | #endif |
1257 | |
1258 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1259 | uint reversebits(uint); |
1260 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1261 | uint2 reversebits(uint2); |
1262 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1263 | uint3 reversebits(uint3); |
1264 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1265 | uint4 reversebits(uint4); |
1266 | |
1267 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1268 | uint64_t reversebits(uint64_t); |
1269 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1270 | uint64_t2 reversebits(uint64_t2); |
1271 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1272 | uint64_t3 reversebits(uint64_t3); |
1273 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_bitreverse) |
1274 | uint64_t4 reversebits(uint64_t4); |
1275 | |
1276 | //===----------------------------------------------------------------------===// |
1277 | // rcp builtins |
1278 | //===----------------------------------------------------------------------===// |
1279 | |
1280 | /// \fn T rcp(T x) |
1281 | /// \brief Calculates a fast, approximate, per-component reciprocal ie 1 / \a x. |
1282 | /// \param x The specified input value. |
1283 | /// |
1284 | /// The return value is the reciprocal of the \a x parameter. |
1285 | |
1286 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1287 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1288 | half rcp(half); |
1289 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1290 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1291 | half2 rcp(half2); |
1292 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1293 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1294 | half3 rcp(half3); |
1295 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1296 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1297 | half4 rcp(half4); |
1298 | |
1299 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1300 | float rcp(float); |
1301 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1302 | float2 rcp(float2); |
1303 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1304 | float3 rcp(float3); |
1305 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1306 | float4 rcp(float4); |
1307 | |
1308 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1309 | double rcp(double); |
1310 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1311 | double2 rcp(double2); |
1312 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1313 | double3 rcp(double3); |
1314 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rcp) |
1315 | double4 rcp(double4); |
1316 | |
1317 | //===----------------------------------------------------------------------===// |
1318 | // rsqrt builtins |
1319 | //===----------------------------------------------------------------------===// |
1320 | |
1321 | /// \fn T rsqrt(T x) |
1322 | /// \brief Returns the reciprocal of the square root of the specified value. |
1323 | /// ie 1 / sqrt( \a x). |
1324 | /// \param x The specified input value. |
1325 | /// |
1326 | /// This function uses the following formula: 1 / sqrt(x). |
1327 | |
1328 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1329 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1330 | half rsqrt(half); |
1331 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1332 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1333 | half2 rsqrt(half2); |
1334 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1335 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1336 | half3 rsqrt(half3); |
1337 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1338 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1339 | half4 rsqrt(half4); |
1340 | |
1341 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1342 | float rsqrt(float); |
1343 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1344 | float2 rsqrt(float2); |
1345 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1346 | float3 rsqrt(float3); |
1347 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_rsqrt) |
1348 | float4 rsqrt(float4); |
1349 | |
1350 | //===----------------------------------------------------------------------===// |
1351 | // round builtins |
1352 | //===----------------------------------------------------------------------===// |
1353 | |
1354 | /// \fn T round(T x) |
1355 | /// \brief Rounds the specified value \a x to the nearest integer. |
1356 | /// \param x The specified input value. |
1357 | /// |
1358 | /// The return value is the \a x parameter, rounded to the nearest integer |
1359 | /// within a floating-point type. Halfway cases are |
1360 | /// rounded to the nearest even value. |
1361 | |
1362 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1363 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1364 | half round(half); |
1365 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1366 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1367 | half2 round(half2); |
1368 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1369 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1370 | half3 round(half3); |
1371 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1372 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1373 | half4 round(half4); |
1374 | |
1375 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1376 | float round(float); |
1377 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1378 | float2 round(float2); |
1379 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1380 | float3 round(float3); |
1381 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_roundeven) |
1382 | float4 round(float4); |
1383 | |
1384 | //===----------------------------------------------------------------------===// |
1385 | // sin builtins |
1386 | //===----------------------------------------------------------------------===// |
1387 | |
1388 | /// \fn T sin(T Val) |
1389 | /// \brief Returns the sine of the input value, \a Val. |
1390 | /// \param Val The input value. |
1391 | |
1392 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1393 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1394 | half sin(half); |
1395 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1396 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1397 | half2 sin(half2); |
1398 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1399 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1400 | half3 sin(half3); |
1401 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1402 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1403 | half4 sin(half4); |
1404 | |
1405 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1406 | float sin(float); |
1407 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1408 | float2 sin(float2); |
1409 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1410 | float3 sin(float3); |
1411 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sin) |
1412 | float4 sin(float4); |
1413 | |
1414 | //===----------------------------------------------------------------------===// |
1415 | // sqrt builtins |
1416 | //===----------------------------------------------------------------------===// |
1417 | |
1418 | /// \fn T sqrt(T Val) |
1419 | /// \brief Returns the square root of the input value, \a Val. |
1420 | /// \param Val The input value. |
1421 | |
1422 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1423 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1424 | half sqrt(half); |
1425 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1426 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1427 | half2 sqrt(half2); |
1428 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1429 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1430 | half3 sqrt(half3); |
1431 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1432 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1433 | half4 sqrt(half4); |
1434 | |
1435 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1436 | float sqrt(float); |
1437 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1438 | float2 sqrt(float2); |
1439 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1440 | float3 sqrt(float3); |
1441 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_sqrt) |
1442 | float4 sqrt(float4); |
1443 | |
1444 | //===----------------------------------------------------------------------===// |
1445 | // trunc builtins |
1446 | //===----------------------------------------------------------------------===// |
1447 | |
1448 | /// \fn T trunc(T Val) |
1449 | /// \brief Returns the truncated integer value of the input value, \a Val. |
1450 | /// \param Val The input value. |
1451 | |
1452 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1453 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1454 | half trunc(half); |
1455 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1456 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1457 | half2 trunc(half2); |
1458 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1459 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1460 | half3 trunc(half3); |
1461 | _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) |
1462 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1463 | half4 trunc(half4); |
1464 | |
1465 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1466 | float trunc(float); |
1467 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1468 | float2 trunc(float2); |
1469 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1470 | float3 trunc(float3); |
1471 | _HLSL_BUILTIN_ALIAS(__builtin_elementwise_trunc) |
1472 | float4 trunc(float4); |
1473 | |
1474 | //===----------------------------------------------------------------------===// |
1475 | // Wave* builtins |
1476 | //===----------------------------------------------------------------------===// |
1477 | |
1478 | /// \brief Counts the number of boolean variables which evaluate to true across |
1479 | /// all active lanes in the current wave. |
1480 | /// |
1481 | /// \param Val The input boolean value. |
1482 | /// \return The number of lanes for which the boolean variable evaluates to |
1483 | /// true, across all active lanes in the current wave. |
1484 | _HLSL_AVAILABILITY(shadermodel, 6.0) |
1485 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_active_count_bits) |
1486 | __attribute__((convergent)) uint WaveActiveCountBits(bool Val); |
1487 | |
1488 | /// \brief Returns the index of the current lane within the current wave. |
1489 | _HLSL_AVAILABILITY(shadermodel, 6.0) |
1490 | _HLSL_BUILTIN_ALIAS(__builtin_hlsl_wave_get_lane_index) |
1491 | __attribute__((convergent)) uint WaveGetLaneIndex(); |
1492 | |
1493 | } // namespace hlsl |
1494 | #endif //_HLSL_HLSL_INTRINSICS_H_ |
1495 |
Warning: This file is not a C or C++ file. It does not have highlighting.