1 #ifndef _VKTUNIFORMBLOCKCASE_HPP 2 #define _VKTUNIFORMBLOCKCASE_HPP 3 /*------------------------------------------------------------------------ 4 * Vulkan Conformance Tests 5 * ------------------------ 6 * 7 * Copyright (c) 2015 The Khronos Group Inc. 8 * Copyright (c) 2015 Samsung Electronics Co., Ltd. 9 * 10 * Licensed under the Apache License, Version 2.0 (the "License"); 11 * you may not use this file except in compliance with the License. 12 * You may obtain a copy of the License at 13 * 14 * http://www.apache.org/licenses/LICENSE-2.0 15 * 16 * Unless required by applicable law or agreed to in writing, software 17 * distributed under the License is distributed on an "AS IS" BASIS, 18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 19 * See the License for the specific language governing permissions and 20 * limitations under the License. 21 * 22 *//*! 23 * \file 24 * \brief Uniform block tests. 25 *//*--------------------------------------------------------------------*/ 26 27 #include "deSharedPtr.hpp" 28 #include "vktTestCase.hpp" 29 #include "tcuDefs.hpp" 30 #include "gluShaderUtil.hpp" 31 32 #include <map> 33 34 namespace vkt 35 { 36 namespace ubo 37 { 38 39 // Uniform block details. 40 41 enum UniformFlags 42 { 43 PRECISION_LOW = (1<<0), 44 PRECISION_MEDIUM = (1<<1), 45 PRECISION_HIGH = (1<<2), 46 PRECISION_MASK = PRECISION_LOW|PRECISION_MEDIUM|PRECISION_HIGH, 47 48 LAYOUT_SHARED = (1<<3), 49 LAYOUT_PACKED = (1<<4), 50 LAYOUT_STD140 = (1<<5), 51 LAYOUT_ROW_MAJOR = (1<<6), 52 LAYOUT_COLUMN_MAJOR = (1<<7), //!< \note Lack of both flags means column-major matrix. 53 LAYOUT_OFFSET = (1<<8), 54 LAYOUT_MASK = LAYOUT_SHARED|LAYOUT_PACKED|LAYOUT_STD140|LAYOUT_ROW_MAJOR|LAYOUT_COLUMN_MAJOR|LAYOUT_OFFSET, 55 56 DECLARE_VERTEX = (1<<9), 57 DECLARE_FRAGMENT = (1<<10), 58 DECLARE_BOTH = DECLARE_VERTEX|DECLARE_FRAGMENT, 59 60 UNUSED_VERTEX = (1<<11), //!< Uniform or struct member is not read in vertex shader. 61 UNUSED_FRAGMENT = (1<<12), //!< Uniform or struct member is not read in fragment shader. 62 UNUSED_BOTH = UNUSED_VERTEX|UNUSED_FRAGMENT 63 }; 64 65 enum MatrixLoadFlags 66 { 67 LOAD_FULL_MATRIX = 0, 68 LOAD_MATRIX_COMPONENTS = 1, 69 }; 70 71 class StructType; 72 73 class VarType 74 { 75 public: 76 VarType (void); 77 VarType (const VarType& other); 78 VarType (glu::DataType basicType, deUint32 flags); 79 VarType (const VarType& elementType, int arraySize); 80 explicit VarType (const StructType* structPtr, deUint32 flags = 0u); 81 ~VarType (void); 82 83 bool isBasicType (void) const { return m_type == TYPE_BASIC; } 84 bool isArrayType (void) const { return m_type == TYPE_ARRAY; } 85 bool isStructType (void) const { return m_type == TYPE_STRUCT; } 86 87 deUint32 getFlags (void) const { return m_flags; } 88 glu::DataType getBasicType (void) const { return m_data.basicType; } 89 90 const VarType& getElementType (void) const { return *m_data.array.elementType; } 91 int getArraySize (void) const { return m_data.array.size; } 92 93 const StructType& getStruct (void) const { return *m_data.structPtr; } 94 95 VarType& operator= (const VarType& other); 96 97 private: 98 enum Type 99 { 100 TYPE_BASIC, 101 TYPE_ARRAY, 102 TYPE_STRUCT, 103 104 TYPE_LAST 105 }; 106 107 Type m_type; 108 deUint32 m_flags; 109 union Data 110 { 111 glu::DataType basicType; 112 struct 113 { 114 VarType* elementType; 115 int size; 116 } array; 117 const StructType* structPtr; 118 119 Data (void) 120 { 121 array.elementType = DE_NULL; 122 array.size = 0; 123 }; 124 } m_data; 125 }; 126 127 class StructMember 128 { 129 public: 130 StructMember (const std::string& name, const VarType& type, deUint32 flags) 131 : m_name(name), m_type(type), m_flags(flags) 132 {} 133 StructMember (void) 134 : m_flags(0) 135 {} 136 137 const std::string& getName (void) const { return m_name; } 138 const VarType& getType (void) const { return m_type; } 139 deUint32 getFlags (void) const { return m_flags; } 140 141 private: 142 std::string m_name; 143 VarType m_type; 144 deUint32 m_flags; 145 }; 146 147 class StructType 148 { 149 public: 150 typedef std::vector<StructMember>::iterator Iterator; 151 typedef std::vector<StructMember>::const_iterator ConstIterator; 152 153 StructType (const std::string& typeName) : m_typeName(typeName) {} 154 ~StructType (void) {} 155 156 const std::string& getTypeName (void) const { return m_typeName; } 157 bool hasTypeName (void) const { return !m_typeName.empty(); } 158 159 inline Iterator begin (void) { return m_members.begin(); } 160 inline ConstIterator begin (void) const { return m_members.begin(); } 161 inline Iterator end (void) { return m_members.end(); } 162 inline ConstIterator end (void) const { return m_members.end(); } 163 164 void addMember (const std::string& name, const VarType& type, deUint32 flags = 0); 165 166 private: 167 std::string m_typeName; 168 std::vector<StructMember> m_members; 169 }; 170 171 class Uniform 172 { 173 public: 174 Uniform (const std::string& name, const VarType& type, deUint32 flags = 0); 175 176 const std::string& getName (void) const { return m_name; } 177 const VarType& getType (void) const { return m_type; } 178 deUint32 getFlags (void) const { return m_flags; } 179 180 private: 181 std::string m_name; 182 VarType m_type; 183 deUint32 m_flags; 184 }; 185 186 class UniformBlock 187 { 188 public: 189 typedef std::vector<Uniform>::iterator Iterator; 190 typedef std::vector<Uniform>::const_iterator ConstIterator; 191 192 UniformBlock (const std::string& blockName); 193 194 const std::string& getBlockName (void) const { return m_blockName; } 195 const std::string& getInstanceName (void) const { return m_instanceName; } 196 bool hasInstanceName (void) const { return !m_instanceName.empty(); } 197 bool isArray (void) const { return m_arraySize > 0; } 198 int getArraySize (void) const { return m_arraySize; } 199 deUint32 getFlags (void) const { return m_flags; } 200 201 void setInstanceName (const std::string& name) { m_instanceName = name; } 202 void setFlags (deUint32 flags) { m_flags = flags; } 203 void setArraySize (int arraySize) { m_arraySize = arraySize; } 204 void addUniform (const Uniform& uniform) { m_uniforms.push_back(uniform); } 205 206 inline Iterator begin (void) { return m_uniforms.begin(); } 207 inline ConstIterator begin (void) const { return m_uniforms.begin(); } 208 inline Iterator end (void) { return m_uniforms.end(); } 209 inline ConstIterator end (void) const { return m_uniforms.end(); } 210 211 private: 212 std::string m_blockName; 213 std::string m_instanceName; 214 std::vector<Uniform> m_uniforms; 215 int m_arraySize; //!< Array size or 0 if not interface block array. 216 deUint32 m_flags; 217 }; 218 219 typedef de::SharedPtr<StructType> StructTypeSP; 220 typedef de::SharedPtr<UniformBlock> UniformBlockSP; 221 222 class ShaderInterface 223 { 224 public: 225 ShaderInterface (void); 226 ~ShaderInterface (void); 227 228 StructType& allocStruct (const std::string& name); 229 void getNamedStructs (std::vector<const StructType*>& structs) const; 230 231 UniformBlock& allocBlock (const std::string& name); 232 233 int getNumUniformBlocks (void) const { return (int)m_uniformBlocks.size(); } 234 const UniformBlock& getUniformBlock (int ndx) const { return *m_uniformBlocks[ndx]; } 235 236 private: 237 std::vector<StructTypeSP> m_structs; 238 std::vector<UniformBlockSP> m_uniformBlocks; 239 }; 240 241 struct BlockLayoutEntry 242 { 243 BlockLayoutEntry (void) 244 : size (0) 245 , blockDeclarationNdx (-1) 246 , bindingNdx (-1) 247 , instanceNdx (-1) 248 { 249 } 250 251 std::string name; 252 int size; 253 std::vector<int> activeUniformIndices; 254 int blockDeclarationNdx; 255 int bindingNdx; 256 int instanceNdx; 257 }; 258 259 struct UniformLayoutEntry 260 { 261 UniformLayoutEntry (void) 262 : type (glu::TYPE_LAST) 263 , size (0) 264 , blockLayoutNdx(-1) 265 , offset (-1) 266 , arrayStride (-1) 267 , matrixStride (-1) 268 , isRowMajor (false) 269 , instanceNdx (0) 270 { 271 } 272 273 std::string name; 274 glu::DataType type; 275 int size; 276 int blockLayoutNdx; 277 int offset; 278 int arrayStride; 279 int matrixStride; 280 bool isRowMajor; 281 int instanceNdx; 282 }; 283 284 class UniformLayout 285 { 286 public: 287 std::vector<BlockLayoutEntry> blocks; 288 std::vector<UniformLayoutEntry> uniforms; 289 290 int getUniformLayoutIndex (int blockDeclarationNdx, const std::string& name) const; 291 int getBlockLayoutIndex (int blockDeclarationNdx, int instanceNdx) const; 292 }; 293 294 class UniformBlockCase : public vkt::TestCase 295 { 296 public: 297 enum BufferMode 298 { 299 BUFFERMODE_SINGLE = 0, //!< Single buffer shared between uniform blocks. 300 BUFFERMODE_PER_BLOCK, //!< Per-block buffers 301 302 BUFFERMODE_LAST 303 }; 304 305 UniformBlockCase (tcu::TestContext& testCtx, 306 const std::string& name, 307 const std::string& description, 308 BufferMode bufferMode, 309 MatrixLoadFlags matrixLoadFlag, 310 bool shuffleUniformMembers = false); 311 ~UniformBlockCase (void); 312 313 virtual void initPrograms (vk::SourceCollections& programCollection) const; 314 virtual TestInstance* createInstance (Context& context) const; 315 316 protected: 317 void init (void); 318 319 BufferMode m_bufferMode; 320 ShaderInterface m_interface; 321 MatrixLoadFlags m_matrixLoadFlag; 322 const bool m_shuffleUniformMembers; //!< Used with explicit offsets to test out of order member offsets 323 324 private: 325 std::string m_vertShaderSource; 326 std::string m_fragShaderSource; 327 328 std::vector<deUint8> m_data; //!< Data. 329 std::map<int, void*> m_blockPointers; //!< Reference block pointers. 330 UniformLayout m_uniformLayout; //!< std140 layout. 331 }; 332 333 } // ubo 334 } // vkt 335 336 #endif // _VKTUNIFORMBLOCKCASE_HPP 337
