08a544372f8b2305244cbbaac3a464faac471217
[WebKit-https.git] / Tools / WebGPUShadingLanguageRI / StandardLibrary.js
1 /*
2  * Copyright (C) 2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25 "use strict";
26
27 // NOTE: The next line is line 28, and we rely on this in Prepare.js.
28 const standardLibrary = `
29 // This is the WSL standard library. Implementations of all of these things are in
30 // Intrinsics.js. The only thing that gets defined before we get here is the Primitive
31 // protocol.
32
33 // Need to bootstrap void first.
34 native Primitive typedef void;
35
36 native Primitive typedef int32;
37 native Primitive typedef uint32;
38 native Primitive typedef bool;
39 typedef int = int32;
40 typedef uint = uint32;
41
42 native Primitive typedef float;
43 native Primitive typedef double;
44
45 native operator int32(uint32);
46 native operator uint32(int32);
47 native operator float(double);
48 native operator double(float);
49
50 native int operator+(int, int);
51 native uint operator+(uint, uint);
52 native float operator+(float, float);
53 native double operator+(double, double);
54 int operator++(int value) { return value + 1; }
55 uint operator++(uint value) { return value + 1; }
56 native int operator-(int, int);
57 native uint operator-(uint, uint);
58 native float operator-(float, float);
59 native double operator-(double, double);
60 int operator--(int value) { return value - 1; }
61 uint operator--(uint value) { return value - 1; }
62 native int operator*(int, int);
63 native uint operator*(uint, uint);
64 native float operator*(float, float);
65 native double operator*(double, double);
66 native int operator/(int, int);
67 native uint operator/(uint, uint);
68 native int operator&(int, int);
69 native int operator|(int, int);
70 native int operator^(int, int);
71 native int operator~(int);
72 native int operator<<(int, uint);
73 native int operator>>(int, uint);
74 native uint operator&(uint, uint);
75 native uint operator|(uint, uint);
76 native uint operator^(uint, uint);
77 native uint operator~(uint);
78 native uint operator<<(uint, uint);
79 native uint operator>>(uint, uint);
80 native float operator/(float, float);
81 native double operator/(double, double);
82 native bool operator==(int, int);
83 native bool operator==(uint, uint);
84 native bool operator==(bool, bool);
85 native bool operator==(float, float);
86 native bool operator==(double, double);
87 native bool operator<(int, int);
88 native bool operator<(uint, uint);
89 native bool operator<(float, float);
90 native bool operator<(double, double);
91 native bool operator<=(int, int);
92 native bool operator<=(uint, uint);
93 native bool operator<=(float, float);
94 native bool operator<=(double, double);
95 native bool operator>(int, int);
96 native bool operator>(uint, uint);
97 native bool operator>(float, float);
98 native bool operator>(double, double);
99 native bool operator>=(int, int);
100 native bool operator>=(uint, uint);
101 native bool operator>=(float, float);
102 native bool operator>=(double, double);
103
104 bool operator&(bool a, bool b)
105 {
106     if (a)
107         return b;
108     return false;
109 }
110 bool operator|(bool a, bool b)
111 {
112     if (a)
113         return true;
114     if (b)
115         return true;
116     return false;
117 }
118 bool operator^(bool a, bool b)
119 {
120     if (a)
121         return !b;
122     return b;
123 }
124 bool operator~(bool value)
125 {
126     return !value;
127 }
128
129 protocol Addable {
130     Addable operator+(Addable, Addable);
131 }
132
133 protocol Equatable {
134     bool operator==(Equatable, Equatable);
135 }
136
137 restricted operator<T> T()
138 {
139     T defaultValue;
140     return defaultValue;
141 }
142
143 restricted operator<T> T(T x)
144 {
145     return x;
146 }
147
148 operator<T:Equatable> bool(T x)
149 {
150     return x != T();
151 }
152
153 struct vec2<T> {
154     T x;
155     T y;
156 }
157
158 typedef int2 = vec2<int>;
159 typedef uint2 = vec2<uint>;
160 typedef float2 = vec2<float>;
161 typedef double2 = vec2<double>;
162
163 operator<T> vec2<T>(T x, T y)
164 {
165     vec2<T> result;
166     result.x = x;
167     result.y = y;
168     return result;
169 }
170
171 bool operator==<T:Equatable>(vec2<T> a, vec2<T> b)
172 {
173     return a.x == b.x && a.y == b.y;
174 }
175
176 thread T^ operator&[]<T>(thread vec2<T>^ foo, uint index)
177 {
178     if (index == 0)
179         return &foo->x;
180     if (index == 1)
181         return &foo->y;
182     return null;
183 }
184
185 struct vec3<T> {
186     T x;
187     T y;
188     T z;
189 }
190
191 typedef int3 = vec3<int>;
192 typedef uint3 = vec3<uint>;
193 typedef float3 = vec3<float>;
194 typedef double3 = vec3<double>;
195
196 operator<T> vec3<T>(T x, T y, T z)
197 {
198     vec3<T> result;
199     result.x = x;
200     result.y = y;
201     result.z = z;
202     return result;
203 }
204
205 operator<T> vec3<T>(vec2<T> v2, T z)
206 {
207     vec3<T> result;
208     result.x = v2.x;
209     result.y = v2.y;
210     result.z = z;
211     return result;
212 }
213
214 operator<T> vec3<T>(T x, vec2<T> v2)
215 {
216     vec3<T> result;
217     result.x = x;
218     result.y = v2.x;
219     result.z = v2.y;
220     return result;
221 }
222
223 bool operator==<T:Equatable>(vec3<T> a, vec3<T> b)
224 {
225     return a.x == b.x && a.y == b.y && a.z == b.z;
226 }
227
228 thread T^ operator&[]<T>(thread vec3<T>^ foo, uint index)
229 {
230     if (index == 0)
231         return &foo->x;
232     if (index == 1)
233         return &foo->y;
234     if (index == 2)
235         return &foo->z;
236     return null;
237 }
238
239 struct vec4<T> {
240     T x;
241     T y;
242     T z;
243     T w;
244 }
245
246 typedef int4 = vec4<int>;
247 typedef uint4 = vec4<uint>;
248 typedef float4 = vec4<float>;
249 typedef double4 = vec4<double>;
250
251 operator<T> vec4<T>(T x, T y, T z, T w)
252 {
253     vec4<T> result;
254     result.x = x;
255     result.y = y;
256     result.z = z;
257     result.w = w;
258     return result;
259 }
260
261 operator<T> vec4<T>(vec2<T> v2, T z, T w)
262 {
263     vec4<T> result;
264     result.x = v2.x;
265     result.y = v2.y;
266     result.z = z;
267     result.w = w;
268     return result;
269 }
270
271 operator<T> vec4<T>(T x, vec2<T> v2, T w)
272 {
273     vec4<T> result;
274     result.x = x;
275     result.y = v2.x;
276     result.z = v2.y;
277     result.w = w;
278     return result;
279 }
280
281 operator<T> vec4<T>(T x, T y, vec2<T> v2)
282 {
283     vec4<T> result;
284     result.x = x;
285     result.y = y;
286     result.z = v2.x;
287     result.w = v2.y;
288     return result;
289 }
290
291 operator<T> vec4<T>(vec2<T> v2a, vec2<T> v2b)
292 {
293     vec4<T> result;
294     result.x = v2a.x;
295     result.y = v2a.y;
296     result.z = v2b.x;
297     result.w = v2b.y;
298     return result;
299 }
300
301 operator<T> vec4<T>(vec3<T> v3, T w)
302 {
303     vec4<T> result;
304     result.x = v3.x;
305     result.y = v3.y;
306     result.z = v3.z;
307     result.w = w;
308     return result;
309 }
310
311 operator<T> vec4<T>(T x, vec3<T> v3)
312 {
313     vec4<T> result;
314     result.x = x;
315     result.y = v3.x;
316     result.z = v3.y;
317     result.w = v3.z;
318     return result;
319 }
320
321 bool operator==<T:Equatable>(vec4<T> a, vec4<T> b)
322 {
323     return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
324 }
325
326 thread T^ operator&[]<T>(thread vec4<T>^ foo, uint index)
327 {
328     if (index == 0)
329         return &foo->x;
330     if (index == 1)
331         return &foo->y;
332     if (index == 2)
333         return &foo->z;
334     if (index == 3)
335         return &foo->w;
336     return null;
337 }
338
339 native thread T^ operator&[]<T>(thread T[], uint);
340 native threadgroup T^ operator&[]<T:Primitive>(threadgroup T[], uint);
341 native device T^ operator&[]<T:Primitive>(device T[], uint);
342 native constant T^ operator&[]<T:Primitive>(constant T[], uint);
343
344 native uint operator.length<T>(thread T[]);
345 native uint operator.length<T:Primitive>(threadgroup T[]);
346 native uint operator.length<T:Primitive>(device T[]);
347 native uint operator.length<T:Primitive>(constant T[]);
348
349 uint operator.length<T, uint length>(T[length])
350 {
351     return length;
352 }
353 `;