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_7A__)
  29 #       define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
  30 #else
  31 #       define VKAPI_ATTR
  32 #endif
  33
  34 #if (DE_OS == DE_OS_WIN32) && ((_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED))
  35 #       define VKAPI_CALL __stdcall
  36 #else
  37 #       define VKAPI_CALL
  38 #endif
  39
  40 #define VK_DEFINE_HANDLE(NAME, TYPE)                                    typedef struct NAME##_s* NAME
  41 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(NAME, TYPE)   typedef Handle<TYPE> NAME
  42
  43 #define VK_DEFINE_PLATFORM_TYPE(NAME, COMPATIBLE)               \
  44 namespace pt {                                                                                  \
  45 struct NAME {                                                                                   \
  46         COMPATIBLE internal;                                                            \
  47         explicit NAME (COMPATIBLE internal_)                            \
  48                 : internal(internal_) {}                                                \
  49 };                                                                                                              \
  50 } // pt
  51
  52 #define VK_MAKE_VERSION(MAJOR, MINOR, PATCH)    (((deUint32)(MAJOR) << 22u) | ((deUint32)(MINOR) << 12u) | (deUint32)(PATCH))
  53 #define VK_BIT(NUM)                                                             (1u<<(deUint32)(NUM))
  54
  55 #define VK_CHECK(EXPR)                                                  vk::checkResult((EXPR), #EXPR, __FILE__, __LINE__)
  56 #define VK_CHECK_MSG(EXPR, MSG)                                 vk::checkResult((EXPR), MSG, __FILE__, __LINE__)
  57
  58 /*--------------------------------------------------------------------*//*!
  59  * \brief Vulkan utilities
  60  *//*--------------------------------------------------------------------*/
  61 namespace vk
  62 {
  63
  64 typedef deUint64        VkDeviceSize;
  65 typedef deUint32        VkSampleMask;
  66 typedef deUint32        VkBool32;
  67 typedef deUint32        VkFlags;
  68
  69 // enum HandleType { HANDLE_TYPE_INSTANCE, ... };
  70 #include "vkHandleType.inl"
  71
  72 template<HandleType Type>
  73 class Handle
  74 {
  75 public:
  76                                 Handle          (void) {} // \note Left uninitialized on purpose
  77                                 Handle          (deUint64 internal) : m_internal(internal) {}
  78
  79         Handle&         operator=       (deUint64 internal)                                     { m_internal = internal; return *this;                  }
  80
  81         bool            operator==      (const Handle<Type>& other) const       { return this->m_internal == other.m_internal;  }
  82         bool            operator!=      (const Handle<Type>& other) const       { return this->m_internal != other.m_internal;  }
  83
  84         bool            operator!       (void) const                                            { return !m_internal;                                                   }
  85
  86         deUint64        getInternal     (void) const                                            { return m_internal;                                                    }
  87
  88         enum { HANDLE_TYPE = Type };
  89
  90 private:
  91         deUint64        m_internal;
  92 };
  93
  94 #include "vkBasicTypes.inl"
  95
  96 enum { VK_QUEUE_FAMILY_IGNORED          = 0xffffffff    };
  97 enum { VK_NO_ATTACHMENT                         = 0xffffffff    };
  98
  99 enum
 100 {
 101         VK_FALSE                = 0,
 102         VK_TRUE                 = 1,
 103         VK_WHOLE_SIZE   = (~0ULL),
 104 };
 105
 106 namespace wsi
 107 {
 108
 109 enum Type
 110 {
 111         TYPE_XLIB = 0,
 112         TYPE_XCB,
 113         TYPE_WAYLAND,
 114         TYPE_MIR,
 115         TYPE_ANDROID,
 116         TYPE_WIN32,
 117
 118         TYPE_LAST
 119 };
 120
 121 } // wsi
 122
 123 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkVoidFunction)                                        (void);
 124
 125 typedef VKAPI_ATTR void*        (VKAPI_CALL* PFN_vkAllocationFunction)                          (void*                                          pUserData,
 126                                                                                                                                                                  size_t                                         size,
 127                                                                                                                                                                  size_t                                         alignment,
 128                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 129 typedef VKAPI_ATTR void*        (VKAPI_CALL* PFN_vkReallocationFunction)                        (void*                                          pUserData,
 130                                                                                                                                                                  void*                                          pOriginal,
 131                                                                                                                                                                  size_t                                         size,
 132                                                                                                                                                                  size_t                                         alignment,
 133                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 134 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkFreeFunction)                                        (void*                                          pUserData,
 135                                                                                                                                                                  void*                                          pMem);
 136 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkInternalAllocationNotification)      (void*                                          pUserData,
 137                                                                                                                                                                  size_t                                         size,
 138                                                                                                                                                                  VkInternalAllocationType       allocationType,
 139                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 140 typedef VKAPI_ATTR void         (VKAPI_CALL* PFN_vkInternalFreeNotification)            (void*                                          pUserData,
 141                                                                                                                                                                  size_t                                         size,
 142                                                                                                                                                                  VkInternalAllocationType       allocationType,
 143                                                                                                                                                                  VkSystemAllocationScope        allocationScope);
 144
 145 typedef VKAPI_ATTR VkBool32     (VKAPI_CALL* PFN_vkDebugReportCallbackEXT)                      (VkDebugReportFlagsEXT          flags,
 146                                                                                                                                                                  VkDebugReportObjectTypeEXT     objectType,
 147                                                                                                                                                                  deUint64                                       object,
 148                                                                                                                                                                  size_t                                         location,
 149                                                                                                                                                                  deInt32                                        messageCode,
 150                                                                                                                                                                  const char*                            pLayerPrefix,
 151                                                                                                                                                                  const char*                            pMessage,
 152                                                                                                                                                                  void*                                          pUserData);
 153
 154 #include "vkStructTypes.inl"
 155
 156 extern "C"
 157 {
 158 #include "vkFunctionPointerTypes.inl"
 159 }
 160
 161 class PlatformInterface
 162 {
 163 public:
 164 #include "vkVirtualPlatformInterface.inl"
 165
 166 protected:
 167                                                 PlatformInterface       (void) {}
 168
 169 private:
 170                                                 PlatformInterface       (const PlatformInterface&);
 171         PlatformInterface&      operator=                       (const PlatformInterface&);
 172 };
 173
 174 class InstanceInterface
 175 {
 176 public:
 177 #include "vkVirtualInstanceInterface.inl"
 178
 179 protected:
 180                                                 InstanceInterface       (void) {}
 181
 182 private:
 183                                                 InstanceInterface       (const InstanceInterface&);
 184         InstanceInterface&      operator=                       (const InstanceInterface&);
 185 };
 186
 187 class DeviceInterface
 188 {
 189 public:
 190 #include "vkVirtualDeviceInterface.inl"
 191
 192 protected:
 193                                                 DeviceInterface         (void) {}
 194
 195 private:
 196                                                 DeviceInterface         (const DeviceInterface&);
 197         DeviceInterface&        operator=                       (const DeviceInterface&);
 198 };
 199
 200 class Error : public tcu::TestError
 201 {
 202 public:
 203                                         Error                           (VkResult error, const char* message, const char* expr, const char* file, int line);
 204                                         Error                           (VkResult error, const std::string& message);
 205         virtual                 ~Error                          (void) throw();
 206
 207         VkResult                getError                        (void) const { return m_error; }
 208
 209 private:
 210         const VkResult  m_error;
 211 };
 212
 213 class OutOfMemoryError : public tcu::ResourceError
 214 {
 215 public:
 216                                         OutOfMemoryError        (VkResult error, const char* message, const char* expr, const char* file, int line);
 217                                         OutOfMemoryError        (VkResult error, const std::string& message);
 218         virtual                 ~OutOfMemoryError       (void) throw();
 219
 220         VkResult                getError                        (void) const { return m_error; }
 221
 222 private:
 223         const VkResult  m_error;
 224 };
 225
 226 void                    checkResult                     (VkResult result, const char* message, const char* file, int line);
 227
 228 } // vk
 229
 230 #endif // _VKDEFS_HPP