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, b.x)&&compare_float(a.y, b.y); }\n";
42 case glu::TYPE_FLOAT_VEC3:
43 return "bool compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z); }\n";
44 case glu::TYPE_FLOAT_VEC4:
45 return "bool compare_vec4 (highp vec4 a, highp vec4 b) { return compare_float(a.x, b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z)&&compare_float(a.w, b.w); }\n";
46 case glu::TYPE_FLOAT_MAT2:
47 return "bool compare_mat2 (highp mat2 a, highp mat2 b) { return compare_vec2(a[0], b[0])&&compare_vec2(a[1], b[1]); }\n";
48 case glu::TYPE_FLOAT_MAT2X3:
49 return "bool compare_mat2x3 (highp mat2x3 a, highp mat2x3 b){ return compare_vec3(a[0], b[0])&&compare_vec3(a[1], b[1]); }\n";
50 case glu::TYPE_FLOAT_MAT2X4:
51 return "bool compare_mat2x4 (highp mat2x4 a, highp mat2x4 b){ return compare_vec4(a[0], b[0])&&compare_vec4(a[1], b[1]); }\n";
52 case glu::TYPE_FLOAT_MAT3X2:
53 return "bool compare_mat3x2 (highp mat3x2 a, highp mat3x2 b){ return compare_vec2(a[0], b[0])&&compare_vec2(a[1], b[1])&&compare_vec2(a[2], b[2]); }\n";
54 case glu::TYPE_FLOAT_MAT3:
55 return "bool compare_mat3 (highp mat3 a, highp mat3 b) { return compare_vec3(a[0], b[0])&&compare_vec3(a[1], b[1])&&compare_vec3(a[2], b[2]); }\n";
56 case glu::TYPE_FLOAT_MAT3X4:
57 return "bool compare_mat3x4 (highp mat3x4 a, highp mat3x4 b){ return compare_vec4(a[0], b[0])&&compare_vec4(a[1], b[1])&&compare_vec4(a[2], b[2]); }\n";
58 case glu::TYPE_FLOAT_MAT4X2:
59 return "bool compare_mat4x2 (highp mat4x2 a, highp mat4x2 b){ return compare_vec2(a[0], b[0])&&compare_vec2(a[1], b[1])&&compare_vec2(a[2], b[2])&&compare_vec2(a[3], b[3]); }\n";
60 case glu::TYPE_FLOAT_MAT4X3:
61 return "bool compare_mat4x3 (highp mat4x3 a, highp mat4x3 b){ return compare_vec3(a[0], b[0])&&compare_vec3(a[1], b[1])&&compare_vec3(a[2], b[2])&&compare_vec3(a[3], b[3]); }\n";
62 case glu::TYPE_FLOAT_MAT4:
63 return "bool compare_mat4 (highp mat4 a, highp mat4 b) { return compare_vec4(a[0], b[0])&&compare_vec4(a[1], b[1])&&compare_vec4(a[2], b[2])&&compare_vec4(a[3], b[3]); }\n";
64 case glu::TYPE_INT:
65 return "bool compare_int (highp int a, highp int b) { return a == b; }\n";
66 case glu::TYPE_INT_VEC2:
67 return "bool compare_ivec2 (highp ivec2 a, highp ivec2 b) { return a == b; }\n";
68 case glu::TYPE_INT_VEC3:
69 return "bool compare_ivec3 (highp ivec3 a, highp ivec3 b) { return a == b; }\n";
70 case glu::TYPE_INT_VEC4:
71 return "bool compare_ivec4 (highp ivec4 a, highp ivec4 b) { return a == b; }\n";
72 case glu::TYPE_UINT:
73 return "bool compare_uint (highp uint a, highp uint b) { return a == b; }\n";
74 case glu::TYPE_UINT_VEC2:
75 return "bool compare_uvec2 (highp uvec2 a, highp uvec2 b) { return a == b; }\n";
76 case glu::TYPE_UINT_VEC3:
77 return "bool compare_uvec3 (highp uvec3 a, highp uvec3 b) { return a == b; }\n";
78 case glu::TYPE_UINT_VEC4:
79 return "bool compare_uvec4 (highp uvec4 a, highp uvec4 b) { return a == b; }\n";
80 case glu::TYPE_BOOL:
81 return "bool compare_bool (bool a, bool b) { return a == b; }\n";
82 case glu::TYPE_BOOL_VEC2:
83 return "bool compare_bvec2 (bvec2 a, bvec2 b) { return a == b; }\n";
84 case glu::TYPE_BOOL_VEC3:
85 return "bool compare_bvec3 (bvec3 a, bvec3 b) { return a == b; }\n";
86 case glu::TYPE_BOOL_VEC4:
87 return "bool compare_bvec4 (bvec4 a, bvec4 b) { return a == b; }\n";
88 case glu::TYPE_FLOAT16:
89 return "bool compare_float16_t(highp float a, highp float b) { return abs(a - b) < 0.05; }\n";
90 case glu::TYPE_FLOAT16_VEC2:
91 return "bool compare_f16vec2 (highp vec2 a, highp vec2 b) { return compare_float(a.x, b.x)&&compare_float(a.y, b.y); }\n";
92 case glu::TYPE_FLOAT16_VEC3:
93 return "bool compare_f16vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z); }\n";
94 case glu::TYPE_FLOAT16_VEC4:
95 return "bool compare_f16vec4 (highp vec4 a, highp vec4 b) { return compare_float(a.x, b.x)&&compare_float(a.y, b.y)&&compare_float(a.z, b.z)&&compare_float(a.w, b.w); }\n";
96 case glu::TYPE_INT8:
97 return "bool compare_int8_t (highp int a, highp int b) { return a == b; }\n";
98 case glu::TYPE_INT8_VEC2:
99 return "bool compare_i8vec2 (highp ivec2 a, highp ivec2 b) { return a == b; }\n";
100 case glu::TYPE_INT8_VEC3:
101 return "bool compare_i8vec3 (highp ivec3 a, highp ivec3 b) { return a == b; }\n";
102 case glu::TYPE_INT8_VEC4:
103 return "bool compare_i8vec4 (highp ivec4 a, highp ivec4 b) { return a == b; }\n";
104 case glu::TYPE_UINT8:
105 return "bool compare_uint8_t (highp uint a, highp uint b) { return a == b; }\n";
106 case glu::TYPE_UINT8_VEC2:
107 return "bool compare_u8vec2 (highp uvec2 a, highp uvec2 b) { return a == b; }\n";
108 case glu::TYPE_UINT8_VEC3:
109 return "bool compare_u8vec3 (highp uvec3 a, highp uvec3 b) { return a == b; }\n";
110 case glu::TYPE_UINT8_VEC4:
111 return "bool compare_u8vec4 (highp uvec4 a, highp uvec4 b) { return a == b; }\n";
112 case glu::TYPE_INT16:
113 return "bool compare_int16_t (highp int a, highp int b) { return a == b; }\n";
114 case glu::TYPE_INT16_VEC2:
115 return "bool compare_i16vec2 (highp ivec2 a, highp ivec2 b) { return a == b; }\n";
116 case glu::TYPE_INT16_VEC3:
117 return "bool compare_i16vec3 (highp ivec3 a, highp ivec3 b) { return a == b; }\n";
118 case glu::TYPE_INT16_VEC4:
119 return "bool compare_i16vec4 (highp ivec4 a, highp ivec4 b) { return a == b; }\n";
120 case glu::TYPE_UINT16:
121 return "bool compare_uint16_t (highp uint a, highp uint b) { return a == b; }\n";
122 case glu::TYPE_UINT16_VEC2:
123 return "bool compare_u16vec2 (highp uvec2 a, highp uvec2 b) { return a == b; }\n";
124 case glu::TYPE_UINT16_VEC3:
125 return "bool compare_u16vec3 (highp uvec3 a, highp uvec3 b) { return a == b; }\n";
126 case glu::TYPE_UINT16_VEC4:
127 return "bool compare_u16vec4 (highp uvec4 a, highp uvec4 b) { return a == b; }\n";
128 default:
129 DE_ASSERT(false);
130 return DE_NULL;
131 }
132 }
133
getCompareDependencies(std::set<glu::DataType> & compareFuncs,glu::DataType basicType)134 void getCompareDependencies (std::set<glu::DataType> &compareFuncs, glu::DataType basicType)
135 {
136 switch (basicType)
137 {
138 case glu::TYPE_FLOAT_VEC2:
139 case glu::TYPE_FLOAT_VEC3:
140 case glu::TYPE_FLOAT_VEC4:
141 case glu::TYPE_FLOAT16_VEC2:
142 case glu::TYPE_FLOAT16_VEC3:
143 case glu::TYPE_FLOAT16_VEC4:
144 compareFuncs.insert(glu::TYPE_FLOAT);
145 compareFuncs.insert(basicType);
146 break;
147
148 case glu::TYPE_FLOAT_MAT2:
149 case glu::TYPE_FLOAT_MAT2X3:
150 case glu::TYPE_FLOAT_MAT2X4:
151 case glu::TYPE_FLOAT_MAT3X2:
152 case glu::TYPE_FLOAT_MAT3:
153 case glu::TYPE_FLOAT_MAT3X4:
154 case glu::TYPE_FLOAT_MAT4X2:
155 case glu::TYPE_FLOAT_MAT4X3:
156 case glu::TYPE_FLOAT_MAT4:
157 compareFuncs.insert(glu::TYPE_FLOAT);
158 compareFuncs.insert(glu::getDataTypeFloatVec(glu::getDataTypeMatrixNumRows(basicType)));
159 compareFuncs.insert(basicType);
160 break;
161
162 default:
163 compareFuncs.insert(basicType);
164 break;
165 }
166 }
167
collectUniqueBasicTypes(std::set<glu::DataType> & basicTypes,const glu::VarType & type)168 void collectUniqueBasicTypes (std::set<glu::DataType> &basicTypes, const glu::VarType &type)
169 {
170 if (type.isStructType())
171 {
172 for (const auto &iter: *type.getStructPtr())
173 collectUniqueBasicTypes(basicTypes, iter.getType());
174 }
175 else if (type.isArrayType())
176 collectUniqueBasicTypes(basicTypes, type.getElementType());
177 else
178 {
179 DE_ASSERT(type.isBasicType());
180 basicTypes.insert(type.getBasicType());
181 }
182 }
183
getPromoteType(glu::DataType type)184 glu::DataType getPromoteType (glu::DataType type)
185 {
186 switch (type)
187 {
188 case glu::TYPE_UINT8:
189 return glu::TYPE_UINT;
190 case glu::TYPE_UINT8_VEC2:
191 return glu::TYPE_UINT_VEC2;
192 case glu::TYPE_UINT8_VEC3:
193 return glu::TYPE_UINT_VEC3;
194 case glu::TYPE_UINT8_VEC4:
195 return glu::TYPE_UINT_VEC4;
196 case glu::TYPE_INT8:
197 return glu::TYPE_INT;
198 case glu::TYPE_INT8_VEC2:
199 return glu::TYPE_INT_VEC2;
200 case glu::TYPE_INT8_VEC3:
201 return glu::TYPE_INT_VEC3;
202 case glu::TYPE_INT8_VEC4:
203 return glu::TYPE_INT_VEC4;
204 case glu::TYPE_UINT16:
205 return glu::TYPE_UINT;
206 case glu::TYPE_UINT16_VEC2:
207 return glu::TYPE_UINT_VEC2;
208 case glu::TYPE_UINT16_VEC3:
209 return glu::TYPE_UINT_VEC3;
210 case glu::TYPE_UINT16_VEC4:
211 return glu::TYPE_UINT_VEC4;
212 case glu::TYPE_INT16:
213 return glu::TYPE_INT;
214 case glu::TYPE_INT16_VEC2:
215 return glu::TYPE_INT_VEC2;
216 case glu::TYPE_INT16_VEC3:
217 return glu::TYPE_INT_VEC3;
218 case glu::TYPE_INT16_VEC4:
219 return glu::TYPE_INT_VEC4;
220 case glu::TYPE_FLOAT16:
221 return glu::TYPE_FLOAT;
222 case glu::TYPE_FLOAT16_VEC2:
223 return glu::TYPE_FLOAT_VEC2;
224 case glu::TYPE_FLOAT16_VEC3:
225 return glu::TYPE_FLOAT_VEC3;
226 case glu::TYPE_FLOAT16_VEC4:
227 return glu::TYPE_FLOAT_VEC4;
228 default:
229 return type;
230 }
231 }
232 } // typecomputil
233 } // vkt
234