# -*- coding: utf-8 -*- #------------------------------------------------------------------------- # drawElements Quality Program utilities # -------------------------------------- # # Copyright 2015 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #------------------------------------------------------------------------- import sys import random import operator import itertools from genutil import * random.seed(1234567) indices = xrange(sys.maxint) # Swizzles: # - vector components # * int, float, bool vectors # * .xyzw, .rgba, .stpq # * illegal to mix # * not allowed for scalar types # * legal to chain: vec4.rgba.xyzw.stpq # * illegal to select more than 4 components # # Subscripts: # - array-like indexing with [] operator # * vectors, matrices # - read & write # - vectors components # * [] accessor # - matrix columns # * [] accessor # * note: mat4[0].x = 1.0; vs mat4[0][0] = 1.0; ?? # * out-of-bounds accesses # # - vector swizzles # * all vector types (bvec2..4, ivec2..4, vec2..4) # * all precisions (lowp, mediump, highp) # * all component names (xyzw, rgba, stpq) # * broadcast each, reverse, N random # - component-masked writes # * all vector types (bvec2..4, ivec2..4, vec2..4) # * all precisions (lowp, mediump, highp) # * all component names (xyzw, rgba, stpq) # * all possible subsets # * all input types (attribute, varying, uniform, tmp) # -> a few hundred cases # - concatenated swizzles # VECTOR_TYPES = [ "vec2", "vec3", "vec4", "ivec2", "ivec3", "ivec4", "bvec2", "bvec3", "bvec4" ] PRECISION_TYPES = [ "lowp", "mediump", "highp" ] INPUT_TYPES = [ "uniform", "varying", "attribute", "tmp" ] SWIZZLE_NAMES = [ "xyzw", "stpq", "rgba" ] def getDataTypeScalarSize (dt): return { "float": 1, "vec2": 2, "vec3": 3, "vec4": 4, "int": 1, "ivec2": 2, "ivec3": 3, "ivec4": 4, "bool": 1, "bvec2": 2, "bvec3": 3, "bvec4": 4, "mat2": 4, "mat3": 9, "mat4": 16 }[dt] if False: class Combinations: def __init__(self, *args): self.lists = list(args) self.numLists = len(args) self.numCombinations = reduce(operator.mul, map(len, self.lists), 1) print(self.lists) print(self.numCombinations) def iterate(self): return [tuple(map(lambda x: x[0], self.lists))] combinations = Combinations(INPUT_TYPES, VECTOR_TYPES, PRECISION_TYPES) print(combinations.iterate()) for (inputType, dataType, precision) in combinations.iterate(): scalarSize = getDataTypeScalarSize(dataType) print(inputType, precision, dataType) def getSwizzlesForWidth(width): if (width == 2): return [(0,), (0,0), (0,1), (1,0), (1,0,1), (0,1,0,0), (1,1,1,1)] elif (width == 3): return [(0,), (2,), (0,2), (2,2), (0,1,2), (2,1,0), (0,0,0), (2,2,2), (2,2,1), (1,0,1), (0,2,0), (0,1,1,0), (2,2,2,2)] elif (width == 4): return [(0,), (3,), (3,0), (3,2), (3,3,3), (1,1,3), (3,2,1), (0,1,2,3), (3,2,1,0), (0,0,0,0), (1,1,1,1), (3,3,3,3), (3,2,2,3), (3,3,3,1), (0,1,0,0), (2,2,3,2)] else: assert False # Templates. s_swizzleCaseTemplate = """ case ${{NAME}} values { ${{VALUES}} } both "" precision mediump float; ${DECLARATIONS} void main() { ${SETUP} ${{OP}} ${OUTPUT} } "" end """[1:] s_simpleIllegalCaseTemplate = """ case ${{NAME}} expect compile_fail values {} both "" precision mediump float; precision mediump int; ${DECLARATIONS} void main() { ${SETUP} ${{OP}} ${OUTPUT} } "" end """[1:] class SwizzleCase(ShaderCase): def __init__(self, name, precision, dataType, swizzle, inputs, outputs): self.name = name self.precision = precision self.dataType = dataType self.swizzle = swizzle self.inputs = inputs self.outputs = outputs self.op = "out0 = in0.%s;" % swizzle def __str__(self): params = { "NAME": self.name, "VALUES": genValues(self.inputs, self.outputs), "OP": self.op } return fillTemplate(s_swizzleCaseTemplate, params) # CASE DECLARATIONS inFloat = [Scalar(x) for x in [0.0, 1.0, 2.0, 3.5, -0.5, -20.125, 36.8125]] inInt = [Scalar(x) for x in [0, 1, 2, 5, 8, 11, -12, -66, -192, 255]] inBool = [Scalar(x) for x in [True, False]] inVec4 = [Vec4(0.0, 0.5, 0.75, 0.825), Vec4(1.0, 1.25, 1.125, 1.75), Vec4(-0.5, -2.25, -4.875, 9.0), Vec4(-32.0, 64.0, -51.0, 24.0), Vec4(-0.75, -1.0/31.0, 1.0/19.0, 1.0/4.0)] inVec3 = toVec3(inVec4) inVec2 = toVec2(inVec4) inIVec4 = toIVec4(inVec4) inIVec3 = toIVec3(inVec4) inIVec2 = toIVec2(inVec4) 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)] inBVec3 = toBVec3(inBVec4) inBVec2 = toBVec2(inBVec4) # \todo [petri] Enable large values when epsilon adapts to the values. 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), 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), #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) ] inMat3 = [Mat3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0), Mat3(6.5, 12.5, -0.75, 32.0, 1.0/32.0, 1.0/64.0, 1.0/8.0, 1.0/16.0, 1.0/32.0), #Mat3(-18.725, -0.5, -0.0125, 19.975, -0.25, -17.75, 9.25, 65.125, -21.425), #Mat3(128.0, -4096.0, -8192.0, 192.0, 768.0, -1536.0, 8192.0, 6144.0, -6144.0) ] inMat2 = [Mat2(1.0, 0.0, 0.0, 1.0), Mat2(6.5, 12.5, -0.75, 9.975), Mat2(6.5, 12.5, -0.75, 9.975), Mat2(8.0, 16.0, -24.0, -16.0), Mat2(1.0/8.0, 1.0/16.0, 1.0/32.0, 1.0/64.0), Mat2(-18.725, -0.5, -0.0125, 19.975), #Mat2(128.0, -4096.0, 192.0, -1536.0), #Mat2(-1536.0, 8192.0, 6144.0, -6144.0) ] INPUTS = { "float": inFloat, "vec2": inVec2, "vec3": inVec3, "vec4": inVec4, "int": inInt, "ivec2": inIVec2, "ivec3": inIVec3, "ivec4": inIVec4, "bool": inBool, "bvec2": inBVec2, "bvec3": inBVec3, "bvec4": inBVec4, "mat2": inMat2, "mat3": inMat3, "mat4": inMat4 } def genConversionCases(inValueList, convFuncList): combinations = list(itertools.product(inValueList, convFuncList)) return [ConversionCase(inValues, convFunc) for (inValues, convFunc) in combinations] allCases = [] # Vector swizzles. vectorSwizzleCases = [] # \todo [petri] Uses fixed precision. for dataType in VECTOR_TYPES: scalarSize = getDataTypeScalarSize(dataType) precision = "mediump" for swizzleComponents in SWIZZLE_NAMES: for swizzleIndices in getSwizzlesForWidth(scalarSize): swizzle = "".join(map(lambda x: swizzleComponents[x], swizzleIndices)) #print("%s %s .%s" % (precision, dataType, swizzle)) caseName = "%s_%s_%s" % (precision, dataType, swizzle) inputs = INPUTS[dataType] outputs = map(lambda x: x.swizzle(swizzleIndices), inputs) outType = outputs[0].typeString() vectorSwizzleCases.append(SwizzleCase(caseName, precision, dataType, swizzle, [("%s in0" % dataType, inputs)], [("%s out0" % outType, outputs)])) # ?? #for dataType in VECTOR_TYPES: # scalarSize = getDataTypeScalarSize(dataType) # for precision in PRECISION_TYPES: # for swizzleIndices in getSwizzlesForWidth(scalarSize): # swizzle = "".join(map(lambda x: "xyzw"[x], swizzleIndices)) # #print("%s %s .%s" % (precision, dataType, swizzle)) # caseName = "%s_%s_%s" % (precision, dataType, swizzle) # inputs = INPUTS[dataType] # outputs = map(lambda x: x.swizzle(swizzleIndices), inputs) # vectorSwizzleCases.append(SwizzleCase(caseName, precision, dataType, swizzle, [("in0", inputs)], [("out0", outputs)])) allCases.append(CaseGroup("vector_swizzles", "Vector Swizzles", vectorSwizzleCases)) # Swizzles: # - vector components # * int, float, bool vectors # * .xyzw, .rgba, .stpq # * illegal to mix # * not allowed for scalar types # * legal to chain: vec4.rgba.xyzw.stpq # * illegal to select more than 4 components # TODO: precisions!! #allCases.append(CaseGroup("vector_swizzles", "Vector Swizzles", # genSwizzleCase([inVec2, inVec3, inVec4], # Main program. if __name__ == "__main__": print("Generating shader case files.") writeAllCases("swizzles.test", allCases)