external/vulkancts/framework/vulkan/vkDefs.hpp

   1 #ifndef _VKDEFS_HPP
   2 #define _VKDEFS_HPP
   3 /*-------------------------------------------------------------------------
   4  * Vulkan CTS Framework
   5  * --------------------
   6  *
   7  * Copyright (c) 2015 Google Inc.
   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  * \file
  23  * \brief Vulkan utilites.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27
  28 #if (DE_OS == DE_OS_ANDROID) && defined(__ARM_ARCH) && defined(__ARM_32BIT_STATE)
  29 #       define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
  30 #else
  31 #       define VKAPI_ATTR
  32 #endif
  33
  34 #if (DE_OS == DE_OS_WIN32) && ((defined(_MSC_VER) && _MSC_VER >= 800) || defined(__MINGW32__) || defined(_STDCALL_SUPPORTED))
  35 #       define VKAPI_CALL __stdcall
  36 #else
  37 #       define VKAPI_CALL
  38 #endif
  39
  40 #define VK_NULL_HANDLE                                                                  DE_NULL
  41 #define VK_DEFINE_HANDLE(NAME, TYPE)                                    typedef struct NAME##_s* NAME
  42 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(NAME, TYPE)   typedef Handle<TYPE> NAME
  43
  44 #define VK_DEFINE_PLATFORM_TYPE(NAME, COMPATIBLE)               \
  45 namespace pt {                                                                                  \
  46 struct NAME {                                                                                   \
  47         COMPATIBLE internal;                                                            \
  48         explicit NAME (COMPATIBLE internal_)                            \
  49                 : internal(internal_) {}                                                \
  50 };                                                                                                              \
  51 } // pt
  52
  53 #define VK_MAKE_API_VERSION(VARIANT, MAJOR, MINOR, PATCH)       \
  54                                                                                                 ((((deUint32)(VARIANT)) << 29) | (((deUint32)(MAJOR)) << 22) | (((deUint32)(MINOR)) << 12) | ((deUint32)(PATCH)))
  55 #define VKSC_API_VARIANT                                                1
  56 #define VK_MAKE_VERSION(MAJOR, MINOR, PATCH)    VK_MAKE_API_VERSION(0, MAJOR, MINOR, PATCH)
  57 #define VK_BIT(NUM)                                                             (1u<<(deUint32)(NUM))
  58
  59 #define VK_API_VERSION_VARIANT(version)                 ((deUint32)(version) >> 29)
  60 #define VK_API_VERSION_MAJOR(version)                   (((deUint32)(version) >> 22) & 0x7FU)
  61 #define VK_API_VERSION_MINOR(version)                   (((deUint32)(version) >> 12) & 0x3FFU)
  62 #define VK_API_VERSION_PATCH(version)                   ((deUint32)(version) & 0xFFFU)
  63
  64 #define VK_CHECK(EXPR)                                                  vk::checkResult((EXPR), #EXPR, __FILE__, __LINE__)
  65 #define VK_CHECK_SUPPORTED(EXPR)                                vk::checkResultSupported((EXPR), #EXPR, __FILE__, __LINE__)
  66 #define VK_CHECK_MSG(EXPR, MSG)                                 vk::checkResult((EXPR), MSG, __FILE__, __LINE__)
  67 #define VK_CHECK_WSI(EXPR)                                              vk::checkWsiResult((EXPR), #EXPR, __FILE__, __LINE__)
  68
  69 #define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \
  70     ((((deUint32)(major)) << 22) | (((deUint32)(minor)) << 12) | ((deUint32)(patch)))
  71
  72 /*--------------------------------------------------------------------*//*!
  73  * \brief Vulkan utilities
  74  *//*--------------------------------------------------------------------*/
  75 namespace vk
  76 {
  77
  78 typedef deUint64        VkDeviceSize;
  79 typedef deUint32        VkSampleMask;
  80 typedef deUint32        VkBool32;
  81 typedef deUint32        VkFlags;
  82 typedef deUint64        VkFlags64;
  83 typedef deUint64        VkDeviceAddress;
  84
  85 // enum HandleType { HANDLE_TYPE_INSTANCE, ... };
  86 #include "vkHandleType.inl"
  87
  88 template<HandleType Type>
  89 class Handle
  90 {
  91 public:
  92                                 Handle          (void) {} // \note Left uninitialized on purpose
  93                                 Handle          (deUint64 internal) : m_internal(internal) {}
  94
  95         Handle&         operator=       (deUint64 internal)                                     { m_internal = internal; return *this;                  }
  96
  97         bool            operator==      (const Handle<Type>& other) const       { return this->m_internal == other.m_internal;  }
  98         bool            operator!=      (const Handle<Type>& other) const       { return this->m_internal != other.m_internal;  }
  99
 100         bool            operator!       (void) const                                            { return !m_internal;                                                   }
 101
 102         deUint64        getInternal     (void) const                                            { return m_internal;                                                    }
 103
 104         enum { HANDLE_TYPE = Type };
 105
 106 private:
 107         deUint64        m_internal;
 108 };
 109
 110 template<HandleType Type>
 111 bool operator<(const Handle<Type>& lhs, const Handle<Type>& rhs)
 112 {
 113         return lhs.getInternal() < rhs.getInternal();
 114 }
 115
 116 #include "vkBasicTypes.inl"
 117
 118 #define VK_CORE_FORMAT_LAST                     ((vk::VkFormat)(vk::VK_FORMAT_ASTC_12x12_SRGB_BLOCK+1))
 119 #define VK_CORE_IMAGE_TILING_LAST       ((vk::VkImageTiling)(vk::VK_IMAGE_TILING_LINEAR+1))
 120 #define VK_CORE_IMAGE_TYPE_LAST         ((vk::VkImageType)(vk::VK_IMAGE_TYPE_3D+1))
 121
 122 enum SpirvVersion
 123 {
 124         SPIRV_VERSION_1_0       = 0,    //!< SPIR-V 1.0
 125         SPIRV_VERSION_1_1       = 1,    //!< SPIR-V 1.1
 126         SPIRV_VERSION_1_2       = 2,    //!< SPIR-V 1.2
 127         SPIRV_VERSION_1_3       = 3,    //!< SPIR-V 1.3
 128         SPIRV_VERSION_1_4       = 4,    //!< SPIR-V 1.4
 129         SPIRV_VERSION_1_5       = 5,    //!< SPIR-V 1.5
 130         SPIRV_VERSION_1_6       = 6,    //!< SPIR-V 1.6
 131
 132         SPIRV_VERSION_LAST
 133 };
 134
 135 typedef struct
 136 {
 137         deUint32        magic;
 138         deUint32        version;
 139         deUint32        generator;
 140         deUint32        bound;
 141 } SpirvBinaryHeader;
 142
 143 namespace wsi
 144 {
 145
 146 enum Type
 147 {
 148         TYPE_XLIB = 0,
 149         TYPE_XCB,
 150         TYPE_WAYLAND,
 151         TYPE_ANDROID,
 152         TYPE_WIN32,
 153         TYPE_MACOS,
 154         TYPE_HEADLESS,
 155         TYPE_DIRECT_DRM,
 156
 157         TYPE_LAST
 158 };
 159
 160 } // wsi
 161
 162 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkVoidFunction)                                        (void);
 163
 164 typedef VKAPI_ATTR void*        (VKAPI_CALL* PFN_vkAllocationFunction)                          (void*                                          pUserData,
 165                                                                                                                                                                  size_t                                         size,
 166                                                                                                                                                                  size_t                                         alignment,
 167                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 168 typedef VKAPI_ATTR void*        (VKAPI_CALL* PFN_vkReallocationFunction)                        (void*                                          pUserData,
 169                                                                                                                                                                  void*                                          pOriginal,
 170                                                                                                                                                                  size_t                                         size,
 171                                                                                                                                                                  size_t                                         alignment,
 172                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 173 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkFreeFunction)                                        (void*                                          pUserData,
 174                                                                                                                                                                  void*                                          pMem);
 175 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkInternalAllocationNotification)      (void*                                          pUserData,
 176                                                                                                                                                                  size_t                                         size,
 177                                                                                                                                                                  VkInternalAllocationType       allocationType,
 178                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 179 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkInternalFreeNotification)            (void*                                          pUserData,
 180                                                                                                                                                                  size_t                                         size,
 181                                                                                                                                                                  VkInternalAllocationType       allocationType,
 182                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 183
 184 #ifndef CTS_USES_VULKANSC
 185
 186 typedef VKAPI_ATTR VkBool32     (VKAPI_CALL* PFN_vkDebugReportCallbackEXT)                      (VkDebugReportFlagsEXT          flags,
 187                                                                                                                                                                  VkDebugReportObjectTypeEXT     objectType,
 188                                                                                                                                                                  deUint64                                       object,
 189                                                                                                                                                                  size_t                                         location,
 190                                                                                                                                                                  deInt32                                        messageCode,
 191                                                                                                                                                                  const char*                            pLayerPrefix,
 192                                                                                                                                                                  const char*                            pMessage,
 193                                                                                                                                                                  void*                                          pUserData);
 194
 195 typedef VKAPI_ATTR PFN_vkVoidFunction (VKAPI_CALL* PFN_vkGetInstanceProcAddrLUNARG)     (VkInstance instance, const char pName);
 196
 197 #endif // CTS_USES_VULKANSC
 198
 199 typedef VKAPI_ATTR VkBool32 (VKAPI_CALL *PFN_vkDebugUtilsMessengerCallbackEXT)  (VkDebugUtilsMessageSeverityFlagBitsEXT                         messageSeverity,
 200                                                                                                                                                                  VkDebugUtilsMessageTypeFlagsEXT                                        messageTypes,
 201                                                                                                                                                                  const struct VkDebugUtilsMessengerCallbackDataEXT*     pCallbackData,
 202                                                                                                                                                                  void*                                                                                          pUserData);
 203
 204 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkDeviceMemoryReportCallbackEXT)       (const struct VkDeviceMemoryReportCallbackDataEXT*      pCallbackData,
 205                                                                                                                                                                  void*                                                                                          pUserData);
 206
 207 #ifdef CTS_USES_VULKANSC
 208 struct VkFaultData;
 209 typedef VKAPI_ATTR void         (VKAPI_CALL *PFN_vkFaultCallbackFunction)                       (VkBool32                                                                                       incompleteFaultData,
 210                                                                                                                                                                  deUint32                                                                                       faultCount,
 211                                                                                                                                                                  VkFaultData*                                                                           pFaultData);
 212 #endif // CTS_USES_VULKANSC
 213
 214 #include "vkStructTypes.inl"
 215
 216 #ifdef CTS_USES_VULKANSC
 217
 218 // substitute required enums and structs removed from VulkanSC specification
 219
 220 enum VkShaderModuleCreateFlagBits
 221 {
 222         VK_SHADER_MODULE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
 223 };
 224 typedef deUint32 VkShaderModuleCreateFlags;
 225
 226 #define VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO VkStructureType(16)
 227 #define VK_OBJECT_TYPE_SHADER_MODULE VkObjectType(15)
 228
 229 struct VkShaderModuleCreateInfo
 230 {
 231         VkStructureType                         sType;
 232         const void*                                     pNext;
 233         VkShaderModuleCreateFlags       flags;
 234         deUintptr                                       codeSize;
 235         const deUint32*                         pCode;
 236 };
 237
 238 #endif // CTS_USES_VULKANSC
 239
 240 typedef void* VkRemoteAddressNV;
 241
 242 extern "C"
 243 {
 244 #include "vkFunctionPointerTypes.inl"
 245 }
 246
 247 class PlatformInterface
 248 {
 249 public:
 250 #include "vkVirtualPlatformInterface.inl"
 251
 252         virtual GetInstanceProcAddrFunc getGetInstanceProcAddr  () const = 0;
 253
 254 protected:
 255                                                                         PlatformInterface               (void) {}
 256
 257 private:
 258                                                                         PlatformInterface               (const PlatformInterface&);
 259         PlatformInterface&                              operator=                               (const PlatformInterface&);
 260 };
 261
 262 class InstanceInterface
 263 {
 264 public:
 265 #include "vkVirtualInstanceInterface.inl"
 266
 267 protected:
 268                                                 InstanceInterface       (void) {}
 269
 270 private:
 271                                                 InstanceInterface       (const InstanceInterface&);
 272         InstanceInterface&      operator=                       (const InstanceInterface&);
 273 };
 274
 275 class DeviceInterface
 276 {
 277 public:
 278 #include "vkVirtualDeviceInterface.inl"
 279
 280 #ifdef CTS_USES_VULKANSC
 281         virtual VkResult        createShaderModule      (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) const = 0;
 282 #endif // CTS_USES_VULKANSC
 283
 284 protected:
 285                                                 DeviceInterface         (void) {}
 286
 287 private:
 288                                                 DeviceInterface         (const DeviceInterface&);
 289         DeviceInterface&        operator=                       (const DeviceInterface&);
 290 };
 291
 292 class Error : public tcu::TestError
 293 {
 294 public:
 295                                         Error                           (VkResult error, const char* message, const char* expr, const char* file, int line);
 296                                         Error                           (VkResult error, const std::string& message);
 297         virtual                 ~Error                          (void) throw();
 298
 299         VkResult                getError                        (void) const { return m_error; }
 300
 301 private:
 302         const VkResult  m_error;
 303 };
 304
 305 class NotSupportedError : public tcu::NotSupportedError
 306 {
 307 public:
 308                                         NotSupportedError       (VkResult error, const char* message, const char* expr, const char* file, int line);
 309                                         NotSupportedError       (VkResult error, const std::string& message);
 310         virtual                 ~NotSupportedError      (void) throw();
 311
 312         VkResult                getError                        (void) const { return m_error; }
 313
 314 private:
 315         const VkResult  m_error;
 316 };
 317
 318 class OutOfMemoryError : public tcu::ResourceError
 319 {
 320 public:
 321                                         OutOfMemoryError        (VkResult error, const char* message, const char* expr, const char* file, int line);
 322                                         OutOfMemoryError        (VkResult error, const std::string& message);
 323         virtual                 ~OutOfMemoryError       (void) throw();
 324
 325         VkResult                getError                        (void) const { return m_error; }
 326
 327 private:
 328         const VkResult  m_error;
 329 };
 330
 331 void                    checkResult                             (VkResult result, const char* message, const char* file, int line);
 332 void                    checkResultSupported    (VkResult result, const char* message, const char* file, int line);
 333 void                    checkWsiResult                  (VkResult result, const char* message, const char* file, int line);
 334
 335 } // vk
 336
 337 #endif // _VKDEFS_HPP