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 23 import sys 24 import random 25 import operator 26 import itertools 27 28 from genutil import * 29 30 random.seed(1234567) 31 indices = 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 77 def 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 87 def 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 93 def combineUVec(comps): 94 return [x.toUint() for x in combineIVec(comps)] 95 96 def 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 102 def 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 109 def combineMat2(comps): return combineMat(2, 2, comps) 110 def combineMat2x3(comps): return combineMat(2, 3, comps) 111 def combineMat2x4(comps): return combineMat(2, 4, comps) 112 def combineMat3x2(comps): return combineMat(3, 2, comps) 113 def combineMat3(comps): return combineMat(3, 3, comps) 114 def combineMat3x4(comps): return combineMat(3, 4, comps) 115 def combineMat4x2(comps): return combineMat(4, 2, comps) 116 def combineMat4x3(comps): return combineMat(4, 3, comps) 117 def 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 125 s_simpleCaseTemplate = """ 126 case ${{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 "" 147 end 148 """[1:] 149 150 s_simpleIllegalCaseTemplate = """ 151 case ${{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 "" 170 end 171 """[1:] 172 173 class 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 188 class 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 206 class 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 222 class 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 243 def toPos (value): 244 if isinstance(value, list): 245 return [toPos(x) for x in value] 246 else: 247 return GenMath.abs(value) 248 249 inFloat = [Scalar(x) for x in [0.0, 1.0, 2.0, 3.5, -0.5, -8.25, -20.125, 36.8125]] 250 inInt = [Scalar(x) for x in [0, 1, 2, 5, 8, 11, -12, -66, -192, 255]] 251 inUint = [Uint(x) for x in [0, 2, 3, 8, 9, 12, 10, 45, 193, 255]] 252 inBool = [Scalar(x) for x in [True, False]] 253 254 inVec4 = [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)] 257 inVec3 = toVec3(inVec4) 258 inVec2 = toVec2(inVec4) 259 inIVec4 = toIVec4(inVec4) 260 inIVec3 = toIVec3(inVec4) 261 inIVec2 = toIVec2(inVec4) 262 inBVec4 = [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)] 263 inBVec3 = toBVec3(inBVec4) 264 inBVec2 = toBVec2(inBVec4) 265 inUVec4 = toUVec4(toPos(inVec4)) 266 inUVec3 = toUVec3(toPos(inVec3)) 267 inUVec2 = toUVec2(toPos(inVec2)) 268 269 # \todo [petri] Enable large values when epsilon adapts to the values. 270 inMat4 = [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 ] 274 inMat2 = [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 284 inMat4x3 = toMat4x3(inMat4) 285 inMat4x2 = toMat4x2(inMat4) 286 inMat3x4 = toMat3x4(inMat4) 287 inMat3 = toMat3(inMat4) 288 inMat3x2 = toMat3x2(inMat4) 289 inMat2x4 = toMat2x4(inMat4) 290 inMat2x3 = toMat2x3(inMat4) 291 292 def genConversionCases(inValueList, convFuncList): 293 combinations = list(itertools.product(inValueList, convFuncList)) 294 return [ConversionCase(inValues, convFunc) for (inValues, convFunc) in combinations] 295 296 def 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 302 def 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 308 def 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 318 allConversionCases = [] 319 320 # Scalar-to-scalar conversions. 321 allConversionCases.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. 326 allConversionCases.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. 331 allConversionCases.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). 336 allConversionCases.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). 341 allConversionCases.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. 350 allConversionCases.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. 359 allConversionCases.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. 363 in2Comp = [[inFloat, inFloat], [inInt, inInt], [inUint, inUint], [inBool, inBool], [inFloat, inInt], [inFloat, inBool], [inInt, inBool], [inInt, inUint], [inUint, inFloat]] 364 in3Comp = [[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]] 365 in4Comp = [[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]] 366 in6Comp = [[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]] 367 in8Comp = [[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]] 368 in9Comp = [[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]] 369 in12Comp = [[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]] 370 in16Comp = [[inVec4, inVec4, inVec4, inVec4], [inIVec4, inIVec4, inIVec4, inIVec4], [inBVec4, inBVec4, inBVec4, inBVec4], [inFloat, inIVec3, inBVec3, inVec4, inIVec2, inFloat, inVec2]] 371 372 allConversionCases.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 380 allConversionCases.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 394 if __name__ == "__main__": 395 print "Generating shader case files." 396 writeAllCases("conversions.test", allConversionCases) 397
