]> git.tdb.fi Git - libs/gl.git/blob - scripts/builtin_funcs.py
Pass the queried position as an argument to get_shadow_factor
[libs/gl.git] / scripts / builtin_funcs.py
1 #!/usr/bin/python3
2
3 import sys
4
5 traits = {
6         "sampler1D": { "CDim": 1, "IDim": 1, "LDim": 1 },
7         "sampler2D": { "CDim": 2, "IDim": 2, "LDim": 2 },
8         "sampler3D": { "CDim": 3, "IDim": 3, "LDim": 3 },
9         "sampler1DArray": { "CDim": 2, "IDim": 2, "LDim": 1 },
10         "sampler2DArray": { "CDim": 3, "IDim": 3, "LDim": 2 },
11         "samplerCube": { "CDim": 3, "IDim": 2, "LDim": 3 },
12         "samplerCubeArray": { "CDim": 4, "IDim": 3, "LDim": 3 },
13         "sampler1DShadow": { "CDim": 3, "IDim": 1, "LDim": 1 },
14         "sampler2DShadow": { "CDim": 3, "IDim": 2, "LDim": 2 },
15         "samplerCubeShadow": { "CDim": 4, "IDim": 2, "LDim": 3 },
16         "sampler1DArrayShadow": { "CDim": 3, "IDim": 2, "LDim": 1 },
17         "sampler2DArrayShadow": { "CDim": 4, "IDim": 3, "LDim": 2 },
18         "samplerCubeArrayShadow": { "IDim": 3, "LDim": 3 },
19         "float": { "Base": "float", "Dim": 1, "Vec": "vec", "Mat": "mat" },
20         "vec2": { "Base": "float", "Dim": 2 },
21         "vec3": { "Base": "float", "Dim": 3 },
22         "vec4": { "Base": "float", "Dim": 4 },
23         "int": { "Base": "int", "Dim": 1, "Vec": "ivec" },
24         "ivec2": { "Base": "int", "Dim": 2 },
25         "ivec3": { "Base": "int", "Dim": 3 },
26         "ivec4": { "Base": "int", "Dim": 4 },
27         "uint": { "Base": "uint", "Dim": 1, "Vec": "uvec" },
28         "uvec2": { "Base": "uint", "Dim": 2 },
29         "uvec3": { "Base": "uint", "Dim": 3 },
30         "uvec4": { "Base": "uint", "Dim": 4 },
31         "bool": { "Base": "bool", "Dim": 1, "Vec": "bvec" },
32         "bvec2": { "Base": "bool", "Dim": 2 },
33         "bvec3": { "Base": "bool", "Dim": 3 },
34         "bvec4": { "Base": "bool", "Dim": 4 },
35         "mat2": { "Cols": 2, "Rows": 2 },
36         "mat3": { "Cols": 3, "Rows": 3 },
37         "mat4": { "Cols": 4, "Rows": 4 },
38         "mat2x3": { "Cols": 2, "Rows": 3 },
39         "mat3x2": { "Cols": 3, "Rows": 2 },
40         "mat2x4": { "Cols": 2, "Rows": 4 },
41         "mat4x2": { "Cols": 4, "Rows": 2 },
42         "mat3x4": { "Cols": 3, "Rows": 4 },
43         "mat4x3": { "Cols": 4, "Rows": 3 }
44 }
45
46 float32vectypes = ("vec2", "vec3", "vec4")
47 float32types = ("float",)+float32vectypes
48 floatvectypes = float32vectypes
49 floattypes = float32types
50 sint32vectypes = ("ivec2", "ivec3", "ivec4")
51 sint32types = ("int",)+sint32vectypes
52 signedtypes = floattypes+sint32types
53 uint32vectypes = ("uvec2", "uvec3", "uvec4")
54 uint32types = ("uint",)+uint32vectypes
55 int32types = sint32types+uint32types
56 unsignedtypes = uint32types
57 arithmetictypes = signedtypes+unsignedtypes
58 arithmeticvectypes = float32vectypes+sint32vectypes+uint32vectypes
59 boolvectypes = ("bvec2", "bvec3", "bvec4")
60 squarematrixtypes = ("mat2", "mat3", "mat4")
61 matrixtypes = squarematrixtypes+("mat2x3", "mat3x2", "mat2x4", "mat4x2", "mat3x4", "mat4x3")
62 flatsamplertypes = ("sampler1D", "sampler2D", "sampler3D", "sampler1DArray", "sampler2DArray")
63 colorsamplertypes = flatsamplertypes+("samplerCube", "samplerCubeArray")
64 shadowsamplertypes = ("sampler1DShadow", "sampler2DShadow", "samplerCubeShadow", "sampler1DArrayShadow", "sampler2DArrayShadow", "samplerCubeArrayShadow")
65 samplertypes = colorsamplertypes+shadowsamplertypes
66 shared_funcs = [
67         # Trigonometric
68         ("T radians(T degrees)", float32types),
69         ("T degrees(T radians)", float32types),
70         ("T sin(T angle)", float32types),
71         ("T cos(T angle)", float32types),
72         ("T tan(T angle)", float32types),
73         ("T asin(T x)", float32types),
74         ("T acos(T x)", float32types),
75         ("T atan(T y, T x)", float32types),
76         ("T atan(T y_over_x)", float32types),
77         ("T sinh(T angle)", float32types),
78         ("T cosh(T angle)", float32types),
79         ("T tanh(T angle)", float32types),
80         ("T asinh(T x)", float32types),
81         ("T acosh(T x)", float32types),
82         ("T atanh(T x)", float32types),
83
84         # Exponential
85         ("T pow(T x, T y)", float32types),
86         ("T exp(T x)", float32types),
87         ("T log(T x)", float32types),
88         ("T exp2(T x)", float32types),
89         ("T log2(T x)", float32types),
90         ("T sqrt(T x)", floattypes),
91         ("T inversesqrt(T x)", floattypes),
92
93         # Common
94         ("T abs(T x)", signedtypes),
95         ("T sign(T x)", signedtypes),
96         ("T floor(T x)", floattypes),
97         ("T trunc(T x)", floattypes),
98         ("T round(T x)", floattypes),
99         ("T roundEven(T x)", floattypes),
100         ("T ceil(T x)", floattypes),
101         ("T fract(T x)", floattypes),
102         ("T mod(T x, T y)", floattypes),
103         ("T mod(T x, T::Base y)", "mod(x, T(y))", floatvectypes),
104         ("T min(T x, T y)", arithmetictypes),
105         ("T min(T x, T::Base y)", "min(x, T(y))", arithmeticvectypes),
106         ("T max(T x, T y)", arithmetictypes),
107         ("T max(T x, T::Base y)", "max(x, T(y))", arithmeticvectypes),
108         ("T clamp(T x, T minVal, T maxVal)", arithmetictypes),
109         ("T clamp(T x, T::Base minVal, T::Base maxVal)", "clamp(x, T(minVal), T(maxVal))", arithmeticvectypes),
110         ("T mix(T x, T y, T a)", floattypes),
111         ("T mix(T x, T y, T::Base a)", "mix(x, y, T(a))", floattypes),
112         ("T mix(T x, T y, bool[T::Dim] a)", arithmetictypes),
113         ("T step(T edge, T x)", floattypes),
114         ("T step(T::Base edge, T x)", "step(T(edge), x)", floatvectypes),
115         ("T smoothstep(T edge0, T edge1, T x)", floattypes),
116         ("T smoothstep(T::Base edge0, T::Base edge1, T x)", "smoothstep(T(edge0), T(edge1), x)", floatvectypes),
117         ("bool[T::Dim] isnan(T x)", floattypes),
118         ("bool[T::Dim] isinf(T x)", floattypes),
119         ("T fma(T a, T b, T c)", floattypes),
120
121         # Geometric
122         ("T::Base length(T x)", floattypes),
123         ("T::Base distance(T p0, T p1)", floattypes),
124         ("T::Base dot(T x, T y)", floattypes),
125         "vec3 cross(vec3 x, vec3 y)",
126         ("T normalize(T x)", floattypes),
127         ("T faceforward(T N, T I, T Nref)", floattypes),
128         ("T reflect(T I, T N)", floattypes),
129         ("T refract(T I, T N, float eta)", floattypes),
130
131         # Matrix
132         ("T matrixCompMult(T x, T y)", matrixtypes),
133         ("T outerProduct(float[T::Rows] c, float[T::Cols] r)", matrixtypes),
134         ("float[T::Rows, T::Cols] transpose(T m)", matrixtypes),
135         ("T determinant(T m)", squarematrixtypes),
136         ("T inverse(T m)", squarematrixtypes),
137
138         # Vector relational
139         ("bool[T::Dim] lessThan(T x, T y)", arithmeticvectypes),
140         ("bool[T::Dim] lessThanEqual(T x, T y)", arithmeticvectypes),
141         ("bool[T::Dim] greaterThan(T x, T y)", arithmeticvectypes),
142         ("bool[T::Dim] greaterThanEqual(T x, T y)", arithmeticvectypes),
143         ("bool[T::Dim] equal(T x, T y)", arithmeticvectypes),
144         ("bool[T::Dim] notEqual(T x, T y)", arithmeticvectypes),
145         ("bool any(T x)", boolvectypes),
146         ("bool all(T x)", boolvectypes),
147         ("bool not(T x)", boolvectypes),
148
149         # Integer
150         ("T bitfieldExtract(T value, int offset, int bits)", int32types),
151         ("T bitfieldInsert(T value, T insert, int offset, int bits)", int32types),
152         ("T bitfieldReverse(T value)", int32types),
153         ("T bitCount(T value)", int32types),
154         ("int[T::Dim] findLSB(T value)", int32types),
155         ("int[T::Dim] findMSB(T value)", int32types),
156
157         # Texture
158         ("int[T::IDim] textureSize(T sampler, int lod)", samplertypes),
159         ("vec2 textureQueryLod(T sampler, float[T::LDim] P)", samplertypes),
160         ("int textureQueryLevels(T sampler)", samplertypes),
161         ("vec4 texture(T sampler, float[T::CDim] P)", colorsamplertypes),
162         ("float texture(T sampler, float[T::CDim] P)", tuple(s for s in shadowsamplertypes if "CubeArray" not in s)),
163         "float texture(samplerCubeArrayShadow sampler, vec4 P, float compare)",
164         ("vec4 textureLod(T sampler, float[T::CDim] P, float lod)", colorsamplertypes),
165         ("vec4 texelFetch(T sampler, int[T::CDim] P, int lod)", flatsamplertypes)
166 ]
167
168 fragment_funcs = [
169         # Derivative
170         ("T dFdx(T p)", float32types),
171         ("T dFdy(T p)", float32types),
172         ("T dFdxFine(T p)", float32types),
173         ("T dFdyFine(T p)", float32types),
174         ("T dFdxCoarse(T p)", float32types),
175         ("T dFdyCoarse(T p)", float32types),
176         ("T fwidth(T p)", float32types),
177         ("T fwidthFine(T p)", float32types),
178         ("T fwidthCoarse(T p)", float32types),
179
180         # Interpolation
181         ("T interpolateAtCentroid(T interpolant)", float32types),
182         ("T interpolateAtSample(T interpolant, int sample)", float32types),
183         ("T interpolateAtOffset(T interpolant, vec2 offset)", float32types)
184 ]
185
186 def tokenize(code):
187         out_tokens = []
188         token = ""
189         for i, c in enumerate(code):
190                 if c.isspace():
191                         continue
192
193                 token += c
194                 n = code[i+1] if i+1<len(code) else " "
195
196                 end = False
197                 if token[0].isalpha():
198                         if not n.isalnum():
199                                 end = True
200                 else:
201                         if n.isalnum() or n.isspace():
202                                 end = True
203
204                 if end:
205                         out_tokens.append(token)
206                         token = ""
207
208         return out_tokens
209
210 def expand_tokens(tokens, i, gentype):
211         t = tokens[i]
212         if t=="T":
213                 t = gentype
214         if i+1<len(tokens):
215                 if tokens[i+1]=="::":
216                         return (traits[t][tokens[i+2]], 3)
217                 elif tokens[i+1]=="[":
218                         sub, advance = expand_tokens(tokens, i+2, gentype)
219                         if tokens[i+2+advance]==",":
220                                 sub2, adv2 = expand_tokens(tokens, i+3+advance, gentype)
221                                 advance += 1+adv2
222                                 if sub2==sub:
223                                         t = traits[t]["Mat"]+str(sub)
224                                 else:
225                                         t = traits[t]["Mat"]+"{}x{}".format(sub, sub2)
226                         elif sub>1:
227                                 t = traits[t]["Vec"]+str(sub)
228                         return (t, 3+advance)
229         return (t, 1)
230
231 def expand_template(template, gentype):
232         result = ""
233         special = True
234         tokens = tokenize(template)
235         i = 0
236         while i<len(tokens):
237                 t, advance = expand_tokens(tokens, i, gentype)
238
239                 if not special and t[0].isalpha():
240                         result += " "
241                 special = not t[0].isalpha()
242
243                 result += t
244                 if t[-1]==",":
245                         result += " "
246
247                 i += advance
248
249         return result
250
251 def generate_functions(funcs):
252         out_lines = []
253         generated = set()
254         for f in funcs:
255                 if type(f)==tuple:
256                         for t in f[-1]:
257                                 decl = expand_template(f[0], t)
258                                 if len(f)>=3:
259                                         decl += " {{ return {}; }}".format(expand_template(f[1], t))
260                                 else:
261                                         decl += ";"
262                                 if not decl in generated:
263                                         out_lines.append(decl+"\n")
264                                         generated.add(decl)
265                 else:
266                         out_lines.append(f+";\n")
267
268         return out_lines
269
270 def generate_file(fn):
271         out_lines = []
272         skip = False
273         for line in open(fn):
274                 if not skip:
275                         out_lines.append(line)
276                 if "BEGIN BUILTIN FUNCTIONS" in line:
277                         skip = True
278                         out_lines += generate_functions(shared_funcs)
279                 elif "BEGIN BUILTIN FRAGMENT FUNCTIONS" in line:
280                         skip = True
281                         out_lines += generate_functions(fragment_funcs)
282                 elif "END BUILTIN" in line:
283                         out_lines.append(line)
284                         skip = False
285
286         open(fn, "w").writelines(out_lines)
287
288 if __name__=="__main__":
289         generate_file(sys.argv[1])