yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

Jay KwakImplement math intrinsics for WGSL (#5078)07166468c

master
branchesmasterall refs →
5.8 KiB279 linesraw
1//TEST:SIMPLE(filecheck=WGSL): -stage compute -entry computeMain -target wgsl
2
3RWStructuredBuffer<int> inputBuffer;
4RWStructuredBuffer<int> outputBuffer;
5
6__generic<T:__BuiltinFloatingPointType>
7bool Test_Scalar()
8{
9    // WGSL-LABEL: Test_Scalar
10
11    const T zero = T(inputBuffer[0]);
12    const T one = T(inputBuffer[1]);
13    const int zeroInt = int(inputBuffer[0]);
14
15    T outFloat1, outFloat2;
16    int outInt;
17
18    return true
19
20        // WGSL: acos(
21        && zero == acos<T>(one)
22
23        // WGSL: acosh(
24        && zero == acosh<T>(one)
25
26        // WGSL: asin(
27        && zero == asin<T>(zero)
28
29        // WGSL: asinh(
30        && zero == asinh<T>(zero)
31
32        // WGSL: atan(
33        && zero == atan<T>(zero)
34
35        // WGSL: atan2(
36        && zero == atan2<T>(zero, zero)
37
38        // WGSL: atanh(
39        && zero == atanh<T>(zero)
40
41        // WGSL: ceil(
42        && zero == ceil<T>(zero)
43
44        // WGSL: cos(
45        && one == cos<T>(zero)
46
47        // WGSL: cosh(
48        && one == cosh<T>(zero)
49
50        // WGSL: exp(
51        && one == exp<T>(zero)
52
53        // WGSL: exp2(
54        && one == exp2<T>(zero)
55
56        // WGSL: abs(
57        && zero == abs<T>(zero)
58
59        // WGSL: floor(
60        && zero == floor<T>(zero)
61
62        // WGSL: fma(
63        && zero == fma(zero, zero, zero)
64
65        // WGSL: max(
66        && zero == max<T>(zero, zero)
67
68        // WGSL: min(
69        && zero == min<T>(zero, zero)
70
71        // WGSL: fract(
72        && zero == fract<T>(zero)
73
74        // WGSL: frexp(
75        && zero == frexp<T>(zero, outInt) && zeroInt == outInt
76
77        // WGSL: ldexp(
78        && zero == ldexp<T>(zero, zeroInt)
79
80        // WGSL: log(
81        && zero == log<T>(one)
82
83        // WGSL: log2(
84        && zero == log2<T>(one)
85
86        // WGSL: modf(
87        && zero == modf<T>(zero, outFloat1)
88
89        // WGSL: pow(
90        && zero == pow<T>(zero, one)
91
92        // WGSL: round(
93        && zero == round<T>(zero)
94
95        // WGSL: sin(
96        && zero == sin<T>(zero)
97
98        // WGSL: sinh(
99        && zero == sinh<T>(zero)
100
101        // WGSL: sqrt(
102        && zero == sqrt<T>(zero)
103
104        // WGSL: tan(
105        && zero == tan<T>(zero)
106
107        // WGSL: tanh(
108        && zero == tanh<T>(zero)
109
110        // WGSL: trunc(
111        && zero == trunc<T>(zero)
112        ;
113}
114
115__generic<T:__BuiltinFloatingPointType, let N : int>
116bool Test_Vector()
117{
118    // WGSL-LABEL: Test_Vector_0
119    const vector<T,N> zero = T(inputBuffer[0]);
120    const vector<T,N> one = T(inputBuffer[1]);
121
122    const vector<int,N> zeroInt = int(inputBuffer[0]);
123
124    vector<T,N> outFloat1, outFloat2;
125    vector<int,N> outInt;
126
127    return true
128        // WGSL: acos(
129        // WGSL-NOT: acos(
130        && zero == acos<T>(one)
131
132        // WGSL: acosh(
133        // WGSL-NOT: acosh(
134        && zero == acosh<T>(one)
135
136        // WGSL: asin(
137        // WGSL-NOT: asin(
138        && zero == asin<T>(zero)
139
140        // WGSL: asinh(
141        // WGSL-NOT: asinh(
142        && zero == asinh<T>(zero)
143
144        // WGSL: atan(
145        // WGSL-NOT: atan(
146        && zero == atan<T>(zero)
147
148        // WGSL: atan2(
149        // WGSL-NOT: atan2(
150        && zero == atan2<T>(zero, zero)
151
152        // WGSL: atanh(
153        // WGSL-NOT: atanh(
154        && zero == atanh<T>(zero)
155
156        // WGSL: ceil(
157        // WGSL-NOT: ceil(
158        && zero == ceil<T>(zero)
159
160        // WGSL: cos(
161        // WGSL-NOT: cos(
162        && one == cos<T>(zero)
163
164        // WGSL: cosh(
165        // WGSL-NOT: cosh(
166        && one == cosh<T>(zero)
167
168        // WGSL: exp(
169        // WGSL-NOT: exp(
170        && one == exp<T>(zero)
171
172        // WGSL: exp2(
173        // WGSL-NOT: exp2(
174        && one == exp2<T>(zero)
175
176        // WGSL: abs(
177        // WGSL-NOT: abs(
178        && zero == abs<T>(zero)
179
180        // WGSL: floor(
181        // WGSL-NOT: floor(
182        && zero == floor<T>(zero)
183
184        // WGSL: fma(
185        // WGSL-NOT: fma(
186        && zero == fma(zero, zero, zero)
187
188        // WGSL: max(
189        // WGSL-NOT: max(
190        && zero == max<T>(zero, zero)
191
192        // WGSL: min(
193        // WGSL-NOT: min(
194        && zero == min<T>(zero, zero)
195
196        // WGSL: fract(
197        // WGSL-NOT: fract(
198        && zero == fract<T>(zero)
199
200        // WGSL: frexp(
201        // WGSL-NOT: frexp(
202        && zero == frexp<T>(zero, outInt) && all(zeroInt == outInt)
203
204        // WGSL: ldexp(
205        // WGSL-NOT: ldexp(
206        && zero == ldexp<T>(zero, zeroInt)
207
208        // WGSL: log(
209        // WGSL-NOT: log(
210        && zero == log<T>(one)
211
212        // WGSL: log2(
213        // WGSL-NOT: log2(
214        && zero == log2<T>(one)
215
216        // WGSL: modf(
217        // WGSL-NOT: modf(
218        && zero == modf<T>(zero, outFloat1)
219
220        // WGSL: pow(
221        // WGSL-NOT: pow(
222        && zero == pow<T>(zero, one)
223
224        // WGSL: round(
225        // WGSL-NOT: round(
226        && zero == round<T>(zero)
227
228        // WGSL: sin(
229        // WGSL-NOT: sin(
230        && zero == sin<T>(zero)
231
232        // WGSL: sinh(
233        // WGSL-NOT: sinh(
234        && zero == sinh<T>(zero)
235
236        // WGSL: sqrt(
237        // WGSL-NOT: sqrt(
238        && zero == sqrt<T>(zero)
239
240        // WGSL: tan(
241        // WGSL-NOT: tan(
242        && zero == tan<T>(zero)
243
244        // WGSL: tanh(
245        // WGSL-NOT: tanh(
246        && zero == tanh<T>(zero)
247
248        // WGSL: trunc(
249        // WGSL-NOT: trunc(
250        && zero == trunc<T>(zero)
251        ;
252
253    // WGSL-LABEL: Test_Vector_1
254}
255
256[numthreads(1,1,1)]
257void computeMain()
258{
259    // GLSL: void main(
260    // GLSL_SPIRV: OpEntryPoint
261    // SPIR: OpEntryPoint
262    // HLSL: void computeMain(
263    // CUDA: void computeMain(
264    // CPP: void _computeMain(
265
266    bool result = true
267        && Test_Scalar<float>()
268        && Test_Vector<float, 2>()
269        && Test_Vector<float, 3>()
270        && Test_Vector<float, 4>()
271        && Test_Scalar<half>()
272        && Test_Vector<half, 2>()
273        && Test_Vector<half, 3>()
274        && Test_Vector<half, 4>()
275        ;
276
277    // BUF: 1
278    outputBuffer[0] = int(result);
279}