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# Swizzles:
34# - vector components
35#   * int, float, bool vectors
36#   * .xyzw, .rgba, .stpq
37#   * illegal to mix
38#   * not allowed for scalar types
39#   * legal to chain: vec4.rgba.xyzw.stpq
40#   * illegal to select more than 4 components
41#
42# Subscripts:
43# - array-like indexing with [] operator
44#   * vectors, matrices
45# - read & write
46# - vectors components
47#   * [] accessor
48# - matrix columns
49#   * [] accessor
50#   * note: mat4[0].x = 1.0; vs mat4[0][0] = 1.0; ??
51#   * out-of-bounds accesses
52
53#
54# - vector swizzles
55#   * all vector types (bvec2..4, ivec2..4, vec2..4)
56#   * all precisions (lowp, mediump, highp)
57#   * all component names (xyzw, rgba, stpq)
58#   * broadcast each, reverse, N random
59# - component-masked writes
60#   * all vector types (bvec2..4, ivec2..4, vec2..4)
61#   * all precisions (lowp, mediump, highp)
62#   * all component names (xyzw, rgba, stpq)
63#   * all possible subsets
64#   * all input types (attribute, varying, uniform, tmp)
65#   -> a few hundred cases
66# - concatenated swizzles
67
68#
69VECTOR_TYPES	= [ "vec2", "vec3", "vec4", "ivec2", "ivec3", "ivec4", "bvec2", "bvec3", "bvec4" ]
70PRECISION_TYPES	= [ "lowp", "mediump", "highp" ]
71INPUT_TYPES		= [ "uniform", "varying", "attribute", "tmp" ]
72SWIZZLE_NAMES	= [ "xyzw", "stpq", "rgba" ]
73
74def getDataTypeScalarSize (dt):
75	return {
76		"float":	1,
77		"vec2":		2,
78		"vec3":		3,
79		"vec4":		4,
80		"int":		1,
81		"ivec2":	2,
82		"ivec3":	3,
83		"ivec4":	4,
84		"bool":		1,
85		"bvec2":	2,
86		"bvec3":	3,
87		"bvec4":	4,
88		"mat2":		4,
89		"mat3":		9,
90		"mat4":		16
91	}[dt]
92
93if False:
94	class Combinations:
95		def __init__(self, *args):
96			self.lists				= list(args)
97			self.numLists			= len(args)
98			self.numCombinations	= reduce(operator.mul, map(len, self.lists), 1)
99			print self.lists
100			print self.numCombinations
101
102		def iterate(self):
103			return [tuple(map(lambda x: x[0], self.lists))]
104
105	combinations = Combinations(INPUT_TYPES, VECTOR_TYPES, PRECISION_TYPES)
106	print combinations.iterate()
107	for (inputType, dataType, precision) in combinations.iterate():
108		scalarSize = getDataTypeScalarSize(dataType)
109		print inputType, precision, dataType
110
111def getSwizzlesForWidth(width):
112	if (width == 2):
113		return [(0,), (0,0), (0,1), (1,0), (1,0,1), (0,1,0,0), (1,1,1,1)]
114	elif (width == 3):
115		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)]
116	elif (width == 4):
117		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)]
118	else:
119		assert False
120
121# Templates.
122
123s_swizzleCaseTemplate = """
124case ${{NAME}}
125	version 300
126	values
127	{
128		${{VALUES}}
129	}
130
131	both ""
132		#version 300 es
133		precision mediump float;
134
135		${DECLARATIONS}
136
137		void main()
138		{
139			${SETUP}
140			${{OP}}
141			${OUTPUT}
142		}
143	""
144end
145"""[1:]
146
147s_simpleIllegalCaseTemplate = """
148case ${{NAME}}
149	version 300
150	expect compile_fail
151	values {}
152
153	both ""
154		#version 300 es
155		precision mediump float;
156		precision mediump int;
157
158		${DECLARATIONS}
159
160		void main()
161		{
162			${SETUP}
163			${{OP}}
164			${OUTPUT}
165		}
166	""
167end
168"""[1:]
169
170class SwizzleCase(ShaderCase):
171	def __init__(self, name, precision, dataType, swizzle, inputs, outputs):
172		self.name		= name
173		self.precision	= precision
174		self.dataType	= dataType
175		self.swizzle	= swizzle
176		self.inputs		= inputs
177		self.outputs	= outputs
178		self.op			= "out0 = in0.%s;" % swizzle
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_swizzleCaseTemplate, params)
187
188# CASE DECLARATIONS
189
190inFloat	= [Scalar(x) for x in [0.0, 1.0, 2.0, 3.5, -0.5, -20.125, 36.8125]]
191inInt	= [Scalar(x) for x in [0, 1, 2, 5, 8, 11, -12, -66, -192, 255]]
192inBool	= [Scalar(x) for x in [True, False]]
193
194inVec4	= [Vec4(0.0, 0.5, 0.75, 0.825), Vec4(1.0, 1.25, 1.125, 1.75),
195		   Vec4(-0.5, -2.25, -4.875, 9.0), Vec4(-32.0, 64.0, -51.0, 24.0),
196		   Vec4(-0.75, -1.0/31.0, 1.0/19.0, 1.0/4.0)]
197inVec3	= toVec3(inVec4)
198inVec2	= toVec2(inVec4)
199inIVec4	= toIVec4(inVec4)
200inIVec3	= toIVec3(inVec4)
201inIVec2	= toIVec2(inVec4)
202inBVec4	= [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)]
203inBVec3	= toBVec3(inBVec4)
204inBVec2	= toBVec2(inBVec4)
205
206# \todo [petri] Enable large values when epsilon adapts to the values.
207inMat4	= [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),
208		   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),
209		   #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)
210		   ]
211inMat3	= [Mat3(1.0, 0.0, 0.0,  0.0, 1.0, 0.0,  0.0, 0.0, 1.0),
212		   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),
213		   #Mat3(-18.725, -0.5, -0.0125,  19.975, -0.25, -17.75,  9.25, 65.125, -21.425),
214		   #Mat3(128.0, -4096.0, -8192.0,  192.0, 768.0, -1536.0,  8192.0, 6144.0, -6144.0)
215		   ]
216inMat2	= [Mat2(1.0, 0.0,  0.0, 1.0),
217		   Mat2(6.5, 12.5,  -0.75, 9.975),
218		   Mat2(6.5, 12.5,  -0.75, 9.975),
219		   Mat2(8.0, 16.0,  -24.0, -16.0),
220		   Mat2(1.0/8.0, 1.0/16.0,  1.0/32.0, 1.0/64.0),
221		   Mat2(-18.725, -0.5,  -0.0125, 19.975),
222		   #Mat2(128.0, -4096.0,  192.0, -1536.0),
223		   #Mat2(-1536.0, 8192.0,  6144.0, -6144.0)
224		   ]
225
226INPUTS = {
227	"float":	inFloat,
228	"vec2":		inVec2,
229	"vec3":		inVec3,
230	"vec4":		inVec4,
231	"int":		inInt,
232	"ivec2":	inIVec2,
233	"ivec3":	inIVec3,
234	"ivec4":	inIVec4,
235	"bool":		inBool,
236	"bvec2":	inBVec2,
237	"bvec3":	inBVec3,
238	"bvec4":	inBVec4,
239	"mat2":		inMat2,
240	"mat3":		inMat3,
241	"mat4":		inMat4
242}
243
244def genConversionCases(inValueList, convFuncList):
245	combinations = list(itertools.product(inValueList, convFuncList))
246	return [ConversionCase(inValues, convFunc) for (inValues, convFunc) in combinations]
247
248allCases = []
249
250# Vector swizzles.
251
252vectorSwizzleCases = []
253
254# \todo [petri] Uses fixed precision.
255for dataType in VECTOR_TYPES:
256	scalarSize = getDataTypeScalarSize(dataType)
257	precision = "mediump"
258	for swizzleComponents in SWIZZLE_NAMES:
259		for swizzleIndices in getSwizzlesForWidth(scalarSize):
260			swizzle = "".join(map(lambda x: swizzleComponents[x], swizzleIndices))
261			#print "%s %s .%s" % (precision, dataType, swizzle)
262			caseName = "%s_%s_%s" % (precision, dataType, swizzle)
263			inputs = INPUTS[dataType]
264			outputs = map(lambda x: x.swizzle(swizzleIndices), inputs)
265			outType = outputs[0].typeString()
266			vectorSwizzleCases.append(SwizzleCase(caseName, precision, dataType, swizzle, [("%s in0" % dataType, inputs)], [("%s out0" % outType, outputs)]))
267
268# ??
269#for dataType in VECTOR_TYPES:
270#	scalarSize = getDataTypeScalarSize(dataType)
271#	for precision in PRECISION_TYPES:
272#		for swizzleIndices in getSwizzlesForWidth(scalarSize):
273#			swizzle = "".join(map(lambda x: "xyzw"[x], swizzleIndices))
274#			#print "%s %s .%s" % (precision, dataType, swizzle)
275#			caseName = "%s_%s_%s" % (precision, dataType, swizzle)
276#			inputs = INPUTS[dataType]
277#			outputs = map(lambda x: x.swizzle(swizzleIndices), inputs)
278#			vectorSwizzleCases.append(SwizzleCase(caseName, precision, dataType, swizzle, [("in0", inputs)], [("out0", outputs)]))
279
280allCases.append(CaseGroup("vector_swizzles", "Vector Swizzles", vectorSwizzleCases))
281
282# Swizzles:
283# - vector components
284#   * int, float, bool vectors
285#   * .xyzw, .rgba, .stpq
286#   * illegal to mix
287#   * not allowed for scalar types
288#   * legal to chain: vec4.rgba.xyzw.stpq
289#   * illegal to select more than 4 components
290
291# TODO: precisions!!
292
293#allCases.append(CaseGroup("vector_swizzles", "Vector Swizzles",
294#	genSwizzleCase([inVec2, inVec3, inVec4],
295
296# Main program.
297
298if __name__ == "__main__":
299	print "Generating shader case files."
300	writeAllCases("swizzles.test", allCases)
301