Home | History | Annotate | Download | only in vulkan
      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 #define VK_CORE_FORMAT_LAST		((vk::VkFormat)(vk::VK_FORMAT_ASTC_12x12_SRGB_BLOCK+1))
     97 
     98 namespace wsi
     99 {
    100 
    101 enum Type
    102 {
    103 	TYPE_XLIB = 0,
    104 	TYPE_XCB,
    105 	TYPE_WAYLAND,
    106 	TYPE_MIR,
    107 	TYPE_ANDROID,
    108 	TYPE_WIN32,
    109 
    110 	TYPE_LAST
    111 };
    112 
    113 } // wsi
    114 
    115 typedef VKAPI_ATTR void		(VKAPI_CALL* PFN_vkVoidFunction)					(void);
    116 
    117 typedef VKAPI_ATTR void*	(VKAPI_CALL* PFN_vkAllocationFunction)				(void*						pUserData,
    118 																				 size_t						size,
    119 																				 size_t						alignment,
    120 																				 VkSystemAllocationScope	allocationScope);
    121 typedef VKAPI_ATTR void*	(VKAPI_CALL* PFN_vkReallocationFunction)			(void*						pUserData,
    122 																				 void*						pOriginal,
    123 																				 size_t						size,
    124 																				 size_t						alignment,
    125 																				 VkSystemAllocationScope	allocationScope);
    126 typedef VKAPI_ATTR void		(VKAPI_CALL* PFN_vkFreeFunction)					(void*						pUserData,
    127 																				 void*						pMem);
    128 typedef VKAPI_ATTR void		(VKAPI_CALL* PFN_vkInternalAllocationNotification)	(void*						pUserData,
    129 																				 size_t						size,
    130 																				 VkInternalAllocationType	allocationType,
    131 																				 VkSystemAllocationScope	allocationScope);
    132 typedef VKAPI_ATTR void		(VKAPI_CALL* PFN_vkInternalFreeNotification)		(void*						pUserData,
    133 																				 size_t						size,
    134 																				 VkInternalAllocationType	allocationType,
    135 																				 VkSystemAllocationScope	allocationScope);
    136 
    137 typedef VKAPI_ATTR VkBool32	(VKAPI_CALL* PFN_vkDebugReportCallbackEXT)			(VkDebugReportFlagsEXT		flags,
    138 																				 VkDebugReportObjectTypeEXT	objectType,
    139 																				 deUint64					object,
    140 																				 size_t						location,
    141 																				 deInt32					messageCode,
    142 																				 const char*				pLayerPrefix,
    143 																				 const char*				pMessage,
    144 																				 void*						pUserData);
    145 
    146 #include "vkStructTypes.inl"
    147 
    148 extern "C"
    149 {
    150 #include "vkFunctionPointerTypes.inl"
    151 }
    152 
    153 class PlatformInterface
    154 {
    155 public:
    156 #include "vkVirtualPlatformInterface.inl"
    157 
    158 protected:
    159 						PlatformInterface	(void) {}
    160 
    161 private:
    162 						PlatformInterface	(const PlatformInterface&);
    163 	PlatformInterface&	operator=			(const PlatformInterface&);
    164 };
    165 
    166 class InstanceInterface
    167 {
    168 public:
    169 #include "vkVirtualInstanceInterface.inl"
    170 
    171 protected:
    172 						InstanceInterface	(void) {}
    173 
    174 private:
    175 						InstanceInterface	(const InstanceInterface&);
    176 	InstanceInterface&	operator=			(const InstanceInterface&);
    177 };
    178 
    179 class DeviceInterface
    180 {
    181 public:
    182 #include "vkVirtualDeviceInterface.inl"
    183 
    184 protected:
    185 						DeviceInterface		(void) {}
    186 
    187 private:
    188 						DeviceInterface		(const DeviceInterface&);
    189 	DeviceInterface&	operator=			(const DeviceInterface&);
    190 };
    191 
    192 class Error : public tcu::TestError
    193 {
    194 public:
    195 					Error				(VkResult error, const char* message, const char* expr, const char* file, int line);
    196 					Error				(VkResult error, const std::string& message);
    197 	virtual			~Error				(void) throw();
    198 
    199 	VkResult		getError			(void) const { return m_error; }
    200 
    201 private:
    202 	const VkResult	m_error;
    203 };
    204 
    205 class OutOfMemoryError : public tcu::ResourceError
    206 {
    207 public:
    208 					OutOfMemoryError	(VkResult error, const char* message, const char* expr, const char* file, int line);
    209 					OutOfMemoryError	(VkResult error, const std::string& message);
    210 	virtual			~OutOfMemoryError	(void) throw();
    211 
    212 	VkResult		getError			(void) const { return m_error; }
    213 
    214 private:
    215 	const VkResult	m_error;
    216 };
    217 
    218 void			checkResult			(VkResult result, const char* message, const char* file, int line);
    219 
    220 } // vk
    221 
    222 #endif // _VKDEFS_HPP
    223