xref: /aosp_15_r20/external/deqp/modules/gles3/scripts/gen-conversions.py (revision 35238bce31c2a825756842865a792f8cf7f89930)
1# -*- coding: utf-8 -*-
2
3#-------------------------------------------------------------------------
4# drawElements Quality Program utilities
5# --------------------------------------
6#
7# Copyright 2015 The Android Open Source Project
8#
9# Licensed under the Apache License, Version 2.0 (the "License");
10# you may not use this file except in compliance with the License.
11# You may obtain a copy of the License at
12#
13#      http://www.apache.org/licenses/LICENSE-2.0
14#
15# Unless required by applicable law or agreed to in writing, software
16# distributed under the License is distributed on an "AS IS" BASIS,
17# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18# See the License for the specific language governing permissions and
19# limitations under the License.
20#
21#-------------------------------------------------------------------------
22
23import sys
24import random
25import operator
26import itertools
27
28from genutil import *
29
30random.seed(1234567)
31indices = xrange(sys.maxint)
32
33# Constructors:
34#
35# - scalars types
36#   * int <-> float <-> bool (also float(float) etc.)
37#   * to bool: zero means false, others true
38#   * from bool: false==0, true==1
39#   * \todo [petri] float<->int rounding rules?
40# - scalar type from vector
41#   * choose the first component
42# - vectors & matrices
43#   * vector from scalar: broadcast to all components
44#   * matrix from scalar: broadcast scalar to diagonal, other components zero
45#   * vector from vector: copy existing components
46#     + illegal: vector from smaller vector
47#   * mat from mat: copy existing components, other components from identity matrix
48#   * from components: consumed by-component in column-major order, must have same
49#     number of components,
50#     + note: vec4(mat2) valid
51#     \todo [petri] Implement!
52# - notes:
53#   * type conversions are always allowed: mat3(ivec3, bvec3, bool, int, float) is valid!
54#
55# Accessors:
56#
57# - vector components
58#   * .xyzw, .rgba, .stpq
59#   * illegal to mix
60#   * now allowed for scalar types
61#   * legal to chain: vec4.rgba.xyzw.stpq
62#   * illegal to select more than 4 components
63#   * array indexing with [] operator
64#   * can also write!
65# - matrix columns
66#   * [] accessor
67#   * note: mat4[0].x = 1.0; vs mat4[0][0] = 1.0; ??
68#   * out-of-bounds accesses
69#
70# \todo [petri] Accessors!
71#
72# Spec issues:
73#
74# - constructing larger vector from smaller: vec3(vec2) ?
75# - base type and size conversion at same time: vec4(bool), int(vec3) allowed?
76
77def combineVec(comps):
78    res = []
79    for ndx in range(len(comps[0])):
80#        for x in comps:
81#            print x[ndx].toFloat().getScalars() ,
82        scalars = reduce(operator.add, [x[ndx].toFloat().getScalars() for x in comps])
83#        print "->", scalars
84        res.append(Vec.fromScalarList(scalars))
85    return res
86
87def combineIVec(comps):
88    res = []
89    for ndx in range(len(comps[0])):
90        res.append(Vec.fromScalarList(reduce(operator.add, [x[ndx].toInt().getScalars() for x in comps])))
91    return res
92
93def combineUVec(comps):
94    return [x.toUint() for x in combineIVec(comps)]
95
96def combineBVec(comps):
97    res = []
98    for ndx in range(len(comps[0])):
99        res.append(Vec.fromScalarList(reduce(operator.add, [x[ndx].toBool().getScalars() for x in comps])))
100    return res
101
102def combineMat(numCols, numRows, comps):
103    res = []
104    for ndx in range(len(comps[0])):
105        scalars = reduce(operator.add, [x[ndx].toFloat().getScalars() for x in comps])
106        res.append(Mat(numCols, numRows, scalars))
107    return res
108
109def combineMat2(comps): return combineMat(2, 2, comps)
110def combineMat2x3(comps): return combineMat(2, 3, comps)
111def combineMat2x4(comps): return combineMat(2, 4, comps)
112def combineMat3x2(comps): return combineMat(3, 2, comps)
113def combineMat3(comps): return combineMat(3, 3, comps)
114def combineMat3x4(comps): return combineMat(3, 4, comps)
115def combineMat4x2(comps): return combineMat(4, 2, comps)
116def combineMat4x3(comps): return combineMat(4, 3, comps)
117def combineMat4(comps): return combineMat(4, 4, comps)
118
119# 0 \+ [f*f for f in lst]
120# r = 0 \+ [f in lst -> f*f]
121# r = 0 \+ lst
122
123# Templates.
124
125s_simpleCaseTemplate = """
126case ${{NAME}}
127    version 300 es
128    values
129    {
130        ${{VALUES}}
131    }
132
133    both ""
134        #version 300 es
135        precision mediump float;
136        precision mediump int;
137
138        ${DECLARATIONS}
139
140        void main()
141        {
142            ${SETUP}
143            ${{OP}}
144            ${OUTPUT}
145        }
146    ""
147end
148"""[1:]
149
150s_simpleIllegalCaseTemplate = """
151case ${{NAME}}
152    version 300 es
153    expect compile_fail
154    values {}
155
156    both ""
157        #version 300 es
158        precision mediump float;
159        precision mediump int;
160
161        ${DECLARATIONS}
162
163        void main()
164        {
165            ${SETUP}
166            ${{OP}}
167            ${OUTPUT}
168        }
169    ""
170end
171"""[1:]
172
173class SimpleCase(ShaderCase):
174    def __init__(self, name, inputs, outputs, op):
175        self.name = name
176        self.inputs = inputs
177        self.outputs = outputs
178        self.op = op
179
180    def __str__(self):
181        params = {
182            "NAME": self.name,
183            "VALUES": genValues(self.inputs, self.outputs),
184            "OP": self.op
185        }
186        return fillTemplate(s_simpleCaseTemplate, params)
187
188class ConversionCase(ShaderCase):
189    def __init__(self, inValues, convFunc):
190        outValues = convFunc(inValues)
191        inType = inValues[0].typeString()
192        outType = outValues[0].typeString()
193        self.name = "%s_to_%s" % (inType, outType)
194        self.op = "out0 = %s(in0);" % outType
195        self.inputs = [("%s in0" % inType, inValues)]
196        self.outputs = [("%s out0" % outType, outValues)]
197
198    def __str__(self):
199        params = {
200            "NAME": self.name,
201            "VALUES": genValues(self.inputs, self.outputs),
202            "OP": self.op
203        }
204        return fillTemplate(s_simpleCaseTemplate, params)
205
206class IllegalConversionCase(ShaderCase):
207    def __init__(self, inValue, outValue):
208        inType = inValue.typeString()
209        outType = outValue.typeString()
210        self.name = "%s_to_%s" % (inType, outType)
211        self.op = "%s in0 = %s;\n%s out0 = %s(in0);" % (inType, str(inValue), outType, outType)
212        self.inType = inType
213        self.outType = outType
214
215    def __str__(self):
216        params = {
217            "NAME": self.name,
218            "OP": self.op
219        }
220        return fillTemplate(s_simpleIllegalCaseTemplate, params)
221
222class CombineCase(ShaderCase):
223    def __init__(self, inComps, combFunc):
224        self.inComps = inComps
225        self.outValues = combFunc(inComps)
226        self.outType = self.outValues[0].typeString()
227        inTypes = [values[0].typeString() for values in inComps]
228        self.name = "%s_to_%s" % ("_".join(inTypes), self.outType)
229        self.inputs = [("%s in%s" % (comp[0].typeString(), ndx), comp) for (comp, ndx) in zip(inComps, indices)]
230        self.outputs = [("%s out0" % self.outType, self.outValues)]
231        self.op = "out0 = %s(%s);" % (self.outType, ", ".join(["in%d" % x for x in range(len(inComps))]))
232
233    def __str__(self):
234        params = {
235            "NAME": self.name,
236            "VALUES": genValues(self.inputs, self.outputs),
237            "OP": self.op
238        }
239        return fillTemplate(s_simpleCaseTemplate, params)
240
241# CASE DECLARATIONS
242
243def toPos (value):
244    if isinstance(value, list):
245        return [toPos(x) for x in value]
246    else:
247        return GenMath.abs(value)
248
249inFloat = [Scalar(x) for x in [0.0, 1.0, 2.0, 3.5, -0.5, -8.25, -20.125, 36.8125]]
250inInt = [Scalar(x) for x in [0, 1, 2, 5, 8, 11, -12, -66, -192, 255]]
251inUint = [Uint(x) for x in [0, 2, 3, 8, 9, 12, 10, 45, 193, 255]]
252inBool = [Scalar(x) for x in [True, False]]
253
254inVec4 = [Vec4(0.0, 0.5, 0.75, 0.825), Vec4(1.0, 1.25, 1.125, 1.75),
255           Vec4(-0.5, -2.25, -4.875, 9.0), Vec4(-32.0, 64.0, -51.0, 24.0),
256           Vec4(-0.75, -1.0/31.0, 1.0/19.0, 1.0/4.0)]
257inVec3 = toVec3(inVec4)
258inVec2 = toVec2(inVec4)
259inIVec4 = toIVec4(inVec4)
260inIVec3 = toIVec3(inVec4)
261inIVec2 = toIVec2(inVec4)
262inBVec4 = [Vec4(True, False, False, True), Vec4(False, False, False, True), Vec4(False, True, False, False), Vec4(True, True, True, True), Vec4(False, False, False, False)]
263inBVec3 = toBVec3(inBVec4)
264inBVec2 = toBVec2(inBVec4)
265inUVec4 = toUVec4(toPos(inVec4))
266inUVec3 = toUVec3(toPos(inVec3))
267inUVec2 = toUVec2(toPos(inVec2))
268
269# \todo [petri] Enable large values when epsilon adapts to the values.
270inMat4 = [Mat4(1.0, 0.0, 0.0, 0.0,  0.0, 1.0, 0.0, 0.0,  0.0, 0.0, 1.0, 0.0,  0.0, 0.0, 0.0, 1.0),
271           Mat4(6.5, 12.5, -0.75, 9.975,  32.0, 1.0/48.0, -8.425, -6.542,  1.0/8.0, 1.0/16.0, 1.0/32.0, 1.0/64.0,  -6.725, -0.5, -0.0125, 9.975),
272           #Mat4(128.0, 256.0, -512.0, -1024.0,  2048.0, -4096.0, 8192.0, -8192.0,  192.0, -384.0, 768.0, -1536.0,  8192.0, -8192.0, 6144.0, -6144.0)
273           ]
274inMat2 = [Mat2(1.0, 0.0,  0.0, 1.0),
275           Mat2(6.5, 12.5,  -0.75, 9.975),
276           Mat2(6.5, 12.5,  -0.75, 9.975),
277           Mat2(8.0, 16.0,  -24.0, -16.0),
278           Mat2(1.0/8.0, 1.0/16.0,  1.0/32.0, 1.0/64.0),
279           Mat2(-18.725, -0.5,  -0.0125, 19.975),
280           #Mat2(128.0, -4096.0,  192.0, -1536.0),
281           #Mat2(-1536.0, 8192.0,  6144.0, -6144.0)
282           ]
283
284inMat4x3 = toMat4x3(inMat4)
285inMat4x2 = toMat4x2(inMat4)
286inMat3x4 = toMat3x4(inMat4)
287inMat3 = toMat3(inMat4)
288inMat3x2 = toMat3x2(inMat4)
289inMat2x4 = toMat2x4(inMat4)
290inMat2x3 = toMat2x3(inMat4)
291
292def genConversionCases(inValueList, convFuncList):
293    combinations = list(itertools.product(inValueList, convFuncList))
294    return [ConversionCase(inValues, convFunc) for (inValues, convFunc) in combinations]
295
296def genIllegalConversionCases(inValueList, outValueList):
297    inValues = [x[0] for x in inValueList]
298    outValues = [x[0] for x in outValueList]
299    combinations = list(itertools.product(inValues, outValues))
300    return [IllegalConversionCase(inVal, outVal) for (inVal, outVal) in combinations]
301
302def shuffleSubLists(outer):
303    return [shuffled(inner) for inner in outer]
304
305# Generate all combinations of CombineCases.
306# inTupleList    a list of tuples of value-lists
307# combFuncList    a list of comb* functions to combine
308def genComponentCases(inCompLists, combFuncList):
309    res = []
310    for comps in inCompLists:
311        maxLen = reduce(max, [len(values) for values in comps])
312        comps = [repeatToLength(values, maxLen) for values in comps]
313        comps = [shuffled(values) for values in comps]
314        for combFunc in combFuncList:
315            res += [CombineCase(comps, combFunc)]
316    return res
317
318allConversionCases = []
319
320# Scalar-to-scalar conversions.
321allConversionCases.append(CaseGroup("scalar_to_scalar", "Scalar to Scalar Conversions",
322    genConversionCases([inFloat, inInt, inUint, inBool], [toFloat, toInt, toBool]) +\
323    genConversionCases([toPos(inFloat), toPos(inInt), inUint, inBool], [toUint])))
324
325# Scalar-to-vector conversions.
326allConversionCases.append(CaseGroup("scalar_to_vector", "Scalar to Vector Conversions",
327    genConversionCases([inFloat, inInt, inUint, inBool], [toVec2, toVec3, toVec4, toIVec2, toIVec3, toIVec4, toBVec2, toBVec3, toBVec4]) +\
328    genConversionCases([toPos(inFloat), toPos(inInt), inUint, inBool], [toUVec2, toUVec3, toUVec4])))
329
330# Vector-to-scalar conversions.
331allConversionCases.append(CaseGroup("vector_to_scalar", "Vector to Scalar Conversions",
332    genConversionCases([inVec2, inVec3, inVec4, inIVec2, inIVec3, inIVec4, inUVec2, inUVec3, inUVec4, inBVec2, inBVec3, inBVec4], [toFloat, toInt, toBool]) +\
333    genConversionCases([toPos(inVec2), toPos(inVec3), toPos(inVec4), toPos(inIVec2), toPos(inIVec3), toPos(inIVec4), inUVec2, inUVec3, inUVec4, inBVec2, inBVec3, inBVec4], [toUint])))
334
335# Illegal vector-to-vector conversions (to longer vec).
336allConversionCases.append(CaseGroup("vector_illegal", "Illegal Vector Conversions",
337    genIllegalConversionCases([inVec2, inIVec2, inUVec2, inBVec2], [inVec3, inIVec3, inUVec3, inBVec3, inVec4, inIVec4, inUVec4, inBVec4]) +\
338    genIllegalConversionCases([inVec3, inIVec3, inUVec3, inBVec3], [inVec4, inIVec4, inUVec4, inBVec4])))
339
340# Vector-to-vector conversions (type conversions, downcasts).
341allConversionCases.append(CaseGroup("vector_to_vector", "Vector to Vector Conversions",
342    genConversionCases([inVec4, inIVec4, inUVec4, inBVec4], [toVec4, toVec3, toVec2, toIVec4, toIVec3, toIVec2, toBVec4, toBVec3, toBVec2]) +\
343    genConversionCases([toPos(inVec4), toPos(inIVec4), inUVec4, inBVec4], [toUVec4, toUVec3, toUVec2]) +\
344    genConversionCases([inVec3, inIVec3, inUVec3, inBVec3], [toVec3, toVec2, toIVec3, toIVec2, toBVec3, toBVec2]) +\
345    genConversionCases([toPos(inVec3), toPos(inIVec3), inUVec3, inBVec3], [toUVec3, toUVec2]) +\
346    genConversionCases([inVec2, inIVec2, inUVec2, inBVec2], [toVec2, toIVec2, toBVec2]) +\
347    genConversionCases([toPos(inVec2), toPos(inIVec2), inUVec2, inBVec2], [toUVec2])))
348
349# Scalar-to-matrix.
350allConversionCases.append(CaseGroup("scalar_to_matrix", "Scalar to Matrix Conversions",
351    genConversionCases([inFloat, inInt, inUint, inBool], [toMat4, toMat4x3, toMat4x2, toMat3x4, toMat3, toMat3x2, toMat2x4, toMat2x3, toMat2])))
352
353# Vector-to-matrix.
354#allConversionCases += genConversionCases([inVec4, inIVec4, inBVec4], [toMat4])
355#allConversionCases += genConversionCases([inVec3, inIVec3, inBVec3], [toMat3])
356#allConversionCases += genConversionCases([inVec2, inIVec2, inBVec2], [toMat2])
357
358# Matrix-to-matrix.
359allConversionCases.append(CaseGroup("matrix_to_matrix", "Matrix to Matrix Conversions",
360    genConversionCases([inMat4, inMat4x3, inMat4x2, inMat3x4, inMat3, inMat3x2, inMat2x4, inMat2x3, inMat2], [toMat4, toMat4x3, toMat4x2, toMat3x4, toMat3, toMat3x2, toMat2x4, toMat2x3, toMat2])))
361
362# Vector-from-components, matrix-from-components.
363in2Comp = [[inFloat, inFloat], [inInt, inInt], [inUint, inUint], [inBool, inBool], [inFloat, inInt], [inFloat, inBool], [inInt, inBool], [inInt, inUint], [inUint, inFloat]]
364in3Comp = [[inFloat, inFloat, inFloat], [inInt, inInt, inInt], [inUint, inUint, inUint], [inBool, inBool, inBool], [inBool, inFloat, inInt], [inVec2, inBool], [inBVec2, inFloat], [inBVec2, inInt], [inBool, inIVec2], [inFloat, inUVec2]]
365in4Comp = [[inVec2, inVec2], [inBVec2, inBVec2], [inFloat, inFloat, inFloat, inFloat], [inInt, inInt, inInt, inInt], [inUint, inUint, inUint, inUint], [inBool, inBool, inBool, inBool], [inBool, inFloat, inInt, inBool], [inVec2, inIVec2], [inVec2, inBVec2], [inBVec3, inFloat], [inVec3, inFloat], [inInt, inIVec2, inInt], [inBool, inFloat, inIVec2], [inFloat, inUVec3], [inInt, inUVec2, inBool]]
366in6Comp = [[inVec3, inVec3], [inBVec3, inBVec3], [inFloat, inFloat, inFloat, inFloat, inFloat, inFloat], [inInt, inInt, inInt, inInt, inInt, inInt], [inBool, inBool, inBool, inBool, inBool, inBool], [inBool, inFloat, inInt, inBool, inFloat, inInt], [inVec3, inIVec3], [inVec2, inBVec4], [inBVec3, inFloat, inIVec2], [inVec3, inFloat, inBVec2]]
367in8Comp = [[inVec3, inVec3, inVec2], [inIVec3, inIVec3, inIVec2], [inVec2, inIVec2, inFloat, inFloat, inInt, inBool], [inBool, inFloat, inInt, inVec2, inBool, inBVec2], [inBool, inBVec2, inInt, inVec4], [inFloat, inBVec4, inIVec2, inBool]]
368in9Comp = [[inVec3, inVec3, inVec3], [inIVec3, inIVec3, inIVec3], [inVec2, inIVec2, inFloat, inFloat, inInt, inBool, inBool], [inBool, inFloat, inInt, inVec2, inBool, inBVec2, inFloat], [inBool, inBVec2, inInt, inVec4, inBool], [inFloat, inBVec4, inIVec2, inBool, inBool]]
369in12Comp = [[inVec4, inVec4, inVec4], [inIVec4, inIVec4, inIVec4], [inVec2, inIVec2, inFloat, inFloat, inFloat, inInt, inInt, inBool, inBool, inBool], [inBool, inFloat, inInt, inVec3, inBool, inBVec3, inFloat, inBool], [inBool, inBVec4, inInt, inVec4, inBool, inFloat], [inFloat, inBVec4, inIVec4, inBool, inBool, inInt]]
370in16Comp = [[inVec4, inVec4, inVec4, inVec4], [inIVec4, inIVec4, inIVec4, inIVec4], [inBVec4, inBVec4, inBVec4, inBVec4], [inFloat, inIVec3, inBVec3, inVec4, inIVec2, inFloat, inVec2]]
371
372allConversionCases.append(CaseGroup("vector_combine", "Vector Combine Constructors",
373    genComponentCases(in4Comp, [combineVec, combineIVec, combineBVec]) +\
374    genComponentCases(toPos(in4Comp), [combineUVec]) +\
375    genComponentCases(in3Comp, [combineVec, combineIVec, combineBVec]) +\
376    genComponentCases(toPos(in3Comp), [combineUVec]) +\
377    genComponentCases(in2Comp, [combineVec, combineIVec, combineBVec]) +\
378    genComponentCases(toPos(in2Comp), [combineUVec])))
379
380allConversionCases.append(CaseGroup("matrix_combine", "Matrix Combine Constructors",
381    genComponentCases(in4Comp, [combineMat2])        +\
382    genComponentCases(in6Comp, [combineMat2x3])    +\
383    genComponentCases(in8Comp, [combineMat2x4])    +\
384    genComponentCases(in6Comp, [combineMat3x2])    +\
385    genComponentCases(in9Comp, [combineMat3])        +\
386    genComponentCases(in12Comp, [combineMat3x4])    +\
387    genComponentCases(in8Comp, [combineMat4x2])    +\
388    genComponentCases(in12Comp, [combineMat4x3])    +\
389    genComponentCases(in16Comp, [combineMat4])
390    ))
391
392# Main program.
393
394if __name__ == "__main__":
395    print("Generating shader case files.")
396    writeAllCases("conversions.test", allConversionCases)
397