1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2021 The Khronos Group Inc.
6 * Copyright (c) 2021 Google LLC.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief Utility functions for generating comparison code for values with different types.
23 *//*--------------------------------------------------------------------*/
24
25 #include "gluShaderUtil.hpp"
26 #include "gluVarTypeUtil.hpp"
27 #include <set>
28
29 namespace vkt
30 {
31 namespace typecomputil
32 {
33
getCompareFuncForType(glu::DataType type)34 const char *getCompareFuncForType(glu::DataType type)
35 {
36 switch (type)
37 {
38 case glu::TYPE_FLOAT:
39 return "bool compare_float (highp float a, highp float b) { return abs(a - b) < 0.05; }\n";
40 case glu::TYPE_FLOAT_VEC2:
41 return "bool compare_vec2 (highp vec2 a, highp vec2 b) { return compare_float(a.x, "
42 "b.x)&&compare_float(a.y, b.y); }\n";
43 case glu::TYPE_FLOAT_VEC3:
44 return "bool compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, "
45 "b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z); }\n";
46 case glu::TYPE_FLOAT_VEC4:
47 return "bool compare_vec4 (highp vec4 a, highp vec4 b) { return compare_float(a.x, "
48 "b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z)&&compare_float(a.w, b.w); }\n";
49 case glu::TYPE_FLOAT_MAT2:
50 return "bool compare_mat2 (highp mat2 a, highp mat2 b) { return compare_vec2(a[0], "
51 "b[0])&&compare_vec2(a[1], b[1]); }\n";
52 case glu::TYPE_FLOAT_MAT2X3:
53 return "bool compare_mat2x3 (highp mat2x3 a, highp mat2x3 b){ return compare_vec3(a[0], "
54 "b[0])&&compare_vec3(a[1], b[1]); }\n";
55 case glu::TYPE_FLOAT_MAT2X4:
56 return "bool compare_mat2x4 (highp mat2x4 a, highp mat2x4 b){ return compare_vec4(a[0], "
57 "b[0])&&compare_vec4(a[1], b[1]); }\n";
58 case glu::TYPE_FLOAT_MAT3X2:
59 return "bool compare_mat3x2 (highp mat3x2 a, highp mat3x2 b){ return compare_vec2(a[0], "
60 "b[0])&&compare_vec2(a[1], b[1])&&compare_vec2(a[2], b[2]); }\n";
61 case glu::TYPE_FLOAT_MAT3:
62 return "bool compare_mat3 (highp mat3 a, highp mat3 b) { return compare_vec3(a[0], "
63 "b[0])&&compare_vec3(a[1], b[1])&&compare_vec3(a[2], b[2]); }\n";
64 case glu::TYPE_FLOAT_MAT3X4:
65 return "bool compare_mat3x4 (highp mat3x4 a, highp mat3x4 b){ return compare_vec4(a[0], "
66 "b[0])&&compare_vec4(a[1], b[1])&&compare_vec4(a[2], b[2]); }\n";
67 case glu::TYPE_FLOAT_MAT4X2:
68 return "bool compare_mat4x2 (highp mat4x2 a, highp mat4x2 b){ return compare_vec2(a[0], "
69 "b[0])&&compare_vec2(a[1], b[1])&&compare_vec2(a[2], b[2])&&compare_vec2(a[3], b[3]); }\n";
70 case glu::TYPE_FLOAT_MAT4X3:
71 return "bool compare_mat4x3 (highp mat4x3 a, highp mat4x3 b){ return compare_vec3(a[0], "
72 "b[0])&&compare_vec3(a[1], b[1])&&compare_vec3(a[2], b[2])&&compare_vec3(a[3], b[3]); }\n";
73 case glu::TYPE_FLOAT_MAT4:
74 return "bool compare_mat4 (highp mat4 a, highp mat4 b) { return compare_vec4(a[0], "
75 "b[0])&&compare_vec4(a[1], b[1])&&compare_vec4(a[2], b[2])&&compare_vec4(a[3], b[3]); }\n";
76 case glu::TYPE_INT:
77 return "bool compare_int (highp int a, highp int b) { return a == b; }\n";
78 case glu::TYPE_INT_VEC2:
79 return "bool compare_ivec2 (highp ivec2 a, highp ivec2 b) { return a == b; }\n";
80 case glu::TYPE_INT_VEC3:
81 return "bool compare_ivec3 (highp ivec3 a, highp ivec3 b) { return a == b; }\n";
82 case glu::TYPE_INT_VEC4:
83 return "bool compare_ivec4 (highp ivec4 a, highp ivec4 b) { return a == b; }\n";
84 case glu::TYPE_UINT:
85 return "bool compare_uint (highp uint a, highp uint b) { return a == b; }\n";
86 case glu::TYPE_UINT_VEC2:
87 return "bool compare_uvec2 (highp uvec2 a, highp uvec2 b) { return a == b; }\n";
88 case glu::TYPE_UINT_VEC3:
89 return "bool compare_uvec3 (highp uvec3 a, highp uvec3 b) { return a == b; }\n";
90 case glu::TYPE_UINT_VEC4:
91 return "bool compare_uvec4 (highp uvec4 a, highp uvec4 b) { return a == b; }\n";
92 case glu::TYPE_BOOL:
93 return "bool compare_bool (bool a, bool b) { return a == b; }\n";
94 case glu::TYPE_BOOL_VEC2:
95 return "bool compare_bvec2 (bvec2 a, bvec2 b) { return a == b; }\n";
96 case glu::TYPE_BOOL_VEC3:
97 return "bool compare_bvec3 (bvec3 a, bvec3 b) { return a == b; }\n";
98 case glu::TYPE_BOOL_VEC4:
99 return "bool compare_bvec4 (bvec4 a, bvec4 b) { return a == b; }\n";
100 case glu::TYPE_FLOAT16:
101 return "bool compare_float16_t(highp float a, highp float b) { return abs(a - b) < 0.05; }\n";
102 case glu::TYPE_FLOAT16_VEC2:
103 return "bool compare_f16vec2 (highp vec2 a, highp vec2 b) { return compare_float(a.x, "
104 "b.x)&&compare_float(a.y, b.y); }\n";
105 case glu::TYPE_FLOAT16_VEC3:
106 return "bool compare_f16vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, "
107 "b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z); }\n";
108 case glu::TYPE_FLOAT16_VEC4:
109 return "bool compare_f16vec4 (highp vec4 a, highp vec4 b) { return compare_float(a.x, "
110 "b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z)&&compare_float(a.w, b.w); }\n";
111 case glu::TYPE_INT8:
112 return "bool compare_int8_t (highp int a, highp int b) { return a == b; }\n";
113 case glu::TYPE_INT8_VEC2:
114 return "bool compare_i8vec2 (highp ivec2 a, highp ivec2 b) { return a == b; }\n";
115 case glu::TYPE_INT8_VEC3:
116 return "bool compare_i8vec3 (highp ivec3 a, highp ivec3 b) { return a == b; }\n";
117 case glu::TYPE_INT8_VEC4:
118 return "bool compare_i8vec4 (highp ivec4 a, highp ivec4 b) { return a == b; }\n";
119 case glu::TYPE_UINT8:
120 return "bool compare_uint8_t (highp uint a, highp uint b) { return a == b; }\n";
121 case glu::TYPE_UINT8_VEC2:
122 return "bool compare_u8vec2 (highp uvec2 a, highp uvec2 b) { return a == b; }\n";
123 case glu::TYPE_UINT8_VEC3:
124 return "bool compare_u8vec3 (highp uvec3 a, highp uvec3 b) { return a == b; }\n";
125 case glu::TYPE_UINT8_VEC4:
126 return "bool compare_u8vec4 (highp uvec4 a, highp uvec4 b) { return a == b; }\n";
127 case glu::TYPE_INT16:
128 return "bool compare_int16_t (highp int a, highp int b) { return a == b; }\n";
129 case glu::TYPE_INT16_VEC2:
130 return "bool compare_i16vec2 (highp ivec2 a, highp ivec2 b) { return a == b; }\n";
131 case glu::TYPE_INT16_VEC3:
132 return "bool compare_i16vec3 (highp ivec3 a, highp ivec3 b) { return a == b; }\n";
133 case glu::TYPE_INT16_VEC4:
134 return "bool compare_i16vec4 (highp ivec4 a, highp ivec4 b) { return a == b; }\n";
135 case glu::TYPE_UINT16:
136 return "bool compare_uint16_t (highp uint a, highp uint b) { return a == b; }\n";
137 case glu::TYPE_UINT16_VEC2:
138 return "bool compare_u16vec2 (highp uvec2 a, highp uvec2 b) { return a == b; }\n";
139 case glu::TYPE_UINT16_VEC3:
140 return "bool compare_u16vec3 (highp uvec3 a, highp uvec3 b) { return a == b; }\n";
141 case glu::TYPE_UINT16_VEC4:
142 return "bool compare_u16vec4 (highp uvec4 a, highp uvec4 b) { return a == b; }\n";
143 default:
144 DE_ASSERT(false);
145 return DE_NULL;
146 }
147 }
148
getCompareDependencies(std::set<glu::DataType> & compareFuncs,glu::DataType basicType)149 void getCompareDependencies(std::set<glu::DataType> &compareFuncs, glu::DataType basicType)
150 {
151 switch (basicType)
152 {
153 case glu::TYPE_FLOAT_VEC2:
154 case glu::TYPE_FLOAT_VEC3:
155 case glu::TYPE_FLOAT_VEC4:
156 case glu::TYPE_FLOAT16_VEC2:
157 case glu::TYPE_FLOAT16_VEC3:
158 case glu::TYPE_FLOAT16_VEC4:
159 compareFuncs.insert(glu::TYPE_FLOAT);
160 compareFuncs.insert(basicType);
161 break;
162
163 case glu::TYPE_FLOAT_MAT2:
164 case glu::TYPE_FLOAT_MAT2X3:
165 case glu::TYPE_FLOAT_MAT2X4:
166 case glu::TYPE_FLOAT_MAT3X2:
167 case glu::TYPE_FLOAT_MAT3:
168 case glu::TYPE_FLOAT_MAT3X4:
169 case glu::TYPE_FLOAT_MAT4X2:
170 case glu::TYPE_FLOAT_MAT4X3:
171 case glu::TYPE_FLOAT_MAT4:
172 compareFuncs.insert(glu::TYPE_FLOAT);
173 compareFuncs.insert(glu::getDataTypeFloatVec(glu::getDataTypeMatrixNumRows(basicType)));
174 compareFuncs.insert(basicType);
175 break;
176
177 default:
178 compareFuncs.insert(basicType);
179 break;
180 }
181 }
182
collectUniqueBasicTypes(std::set<glu::DataType> & basicTypes,const glu::VarType & type)183 void collectUniqueBasicTypes(std::set<glu::DataType> &basicTypes, const glu::VarType &type)
184 {
185 if (type.isStructType())
186 {
187 for (const auto &iter : *type.getStructPtr())
188 collectUniqueBasicTypes(basicTypes, iter.getType());
189 }
190 else if (type.isArrayType())
191 collectUniqueBasicTypes(basicTypes, type.getElementType());
192 else
193 {
194 DE_ASSERT(type.isBasicType());
195 basicTypes.insert(type.getBasicType());
196 }
197 }
198
getPromoteType(glu::DataType type)199 glu::DataType getPromoteType(glu::DataType type)
200 {
201 switch (type)
202 {
203 case glu::TYPE_UINT8:
204 return glu::TYPE_UINT;
205 case glu::TYPE_UINT8_VEC2:
206 return glu::TYPE_UINT_VEC2;
207 case glu::TYPE_UINT8_VEC3:
208 return glu::TYPE_UINT_VEC3;
209 case glu::TYPE_UINT8_VEC4:
210 return glu::TYPE_UINT_VEC4;
211 case glu::TYPE_INT8:
212 return glu::TYPE_INT;
213 case glu::TYPE_INT8_VEC2:
214 return glu::TYPE_INT_VEC2;
215 case glu::TYPE_INT8_VEC3:
216 return glu::TYPE_INT_VEC3;
217 case glu::TYPE_INT8_VEC4:
218 return glu::TYPE_INT_VEC4;
219 case glu::TYPE_UINT16:
220 return glu::TYPE_UINT;
221 case glu::TYPE_UINT16_VEC2:
222 return glu::TYPE_UINT_VEC2;
223 case glu::TYPE_UINT16_VEC3:
224 return glu::TYPE_UINT_VEC3;
225 case glu::TYPE_UINT16_VEC4:
226 return glu::TYPE_UINT_VEC4;
227 case glu::TYPE_INT16:
228 return glu::TYPE_INT;
229 case glu::TYPE_INT16_VEC2:
230 return glu::TYPE_INT_VEC2;
231 case glu::TYPE_INT16_VEC3:
232 return glu::TYPE_INT_VEC3;
233 case glu::TYPE_INT16_VEC4:
234 return glu::TYPE_INT_VEC4;
235 case glu::TYPE_FLOAT16:
236 return glu::TYPE_FLOAT;
237 case glu::TYPE_FLOAT16_VEC2:
238 return glu::TYPE_FLOAT_VEC2;
239 case glu::TYPE_FLOAT16_VEC3:
240 return glu::TYPE_FLOAT_VEC3;
241 case glu::TYPE_FLOAT16_VEC4:
242 return glu::TYPE_FLOAT_VEC4;
243 default:
244 return type;
245 }
246 }
247 } // namespace typecomputil
248 } // namespace vkt
249